Difference between "public void onDestroy()" and "protected void onDestroy()"?
android, code-cleanup, private, protected, void
Solution
Between public and protected there's no difference in the functionality. The only difference is that with public you will be able to call `onDestroy()` on an instance of the activity from any class. With protected you can call only in the same class or subclasses in the same package. With `onDestroy()` I don't see a lot of sense in making it public. It could be actually bad practice.
In other words, just use protected unless you have a very special reason to make it accessible to more classes.
I think the public implementations you saw is just a mistake / not necessary. If you want to test just change it back to protected. If there are no compiler errors, it's not necessary.
Problem
Here is a part of my code: ``` package com.admobsdk_dfp_handler; import com.google.ads.*; import com.google.ads.doubleclick.*; import android.os.Bundle; import android.os.Handler; import android.app.Activity; import android.view.Menu; import android.widget.RelativeLayout; public class AdMobSDK_DFP_Handler extends Activity { private DfpAdView adView; private static final String adUnitId = "/7732/test_portal7/android_app1_test_portal7/top_banner_non_sdk_application_android_app1_test_portal7"; private Handler handler = new Handler(); private Runnable runnable = new Runnable() { public void run() { adView.loadAd(new AdRequest()); handler.postDelayed(this, 5000); } }; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_ad_mob_sdk__dfp__handler); adView = new DfpAdView(this, AdSize.BANNER, adUnitId); RelativeLayout layout = (RelativeLayout) findViewById(R.id.mainLayout); layout.addView(adView); adView.loadAd(new AdRequest()); }; @Override protected void onPause() { handler.removeCallbacks(runnable); super.onPause(); } @Override protected void onResume() { handler.postDelayed(runnable, 5000); super.onResume(); } @Override protected void onDestroy() { handler.removeCallbacks(runnable); super.onDestroy(); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_ad_mob_sdk__dfp__handler, menu); return true; } } ``` protected void onDestroy() is used to clean up the program. However, I saw some sample projects, which usually use public void onDestroy() to do the clean up. As I know that in Java, protected method can be accessed within a package, and public method can be accessed anywhere. But usually a class has its own onDestroy(), so is it mean that either one can be used?? Any points I have to concern about while choosing between them? Thank you for your help.