Android 面试题(一)

1静态内部类，内部类，匿名内部类，为什么内部类会持有外部类的引用？持有的应用是this，还是别的？
静态内部类：用static修饰的内部类
内部类：在一个类的内部重新创建一个类
匿名内部类：使用new生成的内部类
内部类的产生依赖于外部类，持有的是类名.this

2arraylist和vector的区别：
java1.2 以后开始引入的vector
vector：线程同步，当vector的元素超过初始大小的时候，vector会将他的容量翻倍。
arraylist：线程不同步，当arraylist的元素超过初始大小时，容量增加50%。。。

3Java中try catch finally 执行顺序
try===异常===catch===finally最后肯定走

4Java switch的作用类型
byte，int ，short，char，枚举，五中类型
java1.7以后增加了String

5activity 和fragment的生命周期
activity : onCreate==》onStart===》onResume===>onPause===>onStop===>onDestroy
fragment: onAttach===>onCreate===>onCreateView===>onActityCreated===>onStart===>onResume===>onPause===>onStop===>onDestroyView===>onDestroy===>onDetach

6Android Activity什么时候进入“运行态”，什么时候进入“暂停态”，什么时候进入“停止态”？重新进入“运行态”需要经过哪几个生命周期？
运行态：经过onResume后进入运行态
暂停态：新的activity没有完全盖住原来的activity时，原来的activity进入暂停态
停止态: 新的activity完全盖住原来的activity时，原来的activity进入停止态
暂停态===》运行态：onPause==》onResume
停止态===》运行态：onStop==》onRestart==》onStart===》onResume

　onCreate: 在这里创建界面 ，做一些数据的初始化工作
　onStart: 到这一步变成用户可见不可交互 的
　onResume: 变成和用户可交互 的，（在activity 栈系统通过栈的方式管理这些个
　Activity的最上面，运行完弹出栈，则回到上一个Activity)
　onPause: 到这一步是可见但不可交互 的，系统会停止动画 等消耗CPU 的事情
　从上文的描述已经知道，应该在这里保存你的一些数据,因为这个时候
　你的程序的优先级降低，有可能被系统收回。在这里保存的数据，应该在
　onResume里读出来，注意：这个方法里做的事情时间要短，因为下一
　个activity不会等到这个方法完成才启动
　onstop: 变得不可见 ，被下一个activity覆盖了
　onDestroy: 这是activity被干掉前最后一个被调用方法了，可能是外面类调用finish方
　法或者是系统为了节省空间将它暂时性的干掉，可以用isFinishing()来判
　断它，如果你有一个Progress Dialog在线程中转动，请在onDestroy里
　把他cancel掉，不然等线程结束的时候，调用Dialog的cancel方法会抛
　异常的。
　
　7Android 横竖屏切换生命周期的变化？
　 ①竖屏装换成横屏：onSaveInstanceState–>onPause–>onStop–>onDestroy–>onCreate–>onStart–>onRestoreInstanceState–>onResume–>
　 ②由横屏转竖屏生命周期①执行两遍。
　 总结：
1、不设置Activity的android:configChanges时，切屏会重新调用各个生命周期，切 横屏时会执行一次，切竖屏时会执行两次
2、设置Activity的android:configChanges=”orientation”时，切屏还是会重新调用各个生命周期，切横、竖屏时只会执行一次
3、设置Activity的android:configChanges=”orientation|keyboardHidden”时，切屏不会重新调用各个生命周期，只会执行onConfigurationChanged方法

8Android onPause保存数据和onSaveInstanceState方法的区别？
onSaveInstanceState这个方法肯定在onstop之前，但是不一定在onpause之前或者 之后
onSaveInstanceState:保存一些临时数据，比如：editext输入的文字，checkbox的选中状态，scrollview滑动位置，视频的播放进度。Android的editext等控件具有自动保存的功能，没必要实现onSaveInstanceState方法，但是必须要有id。
onPause：保存持久化的数据，比如忘数据库中插入一条数据。但是不要做大量的操作。否则会影响activity入栈。
9 dipatchTouchEevent，onInterceptTouchEvent，onTouchEvent三者的区别？
dispatchTouchEvent：事件分发
onInterceptTouchEvent：事件拦截
onTouchEvent：事件处理
10 ReMoteView在哪些功能中使用？
Notifycation(自定义通知栏布局)和appWiget
11SurfaceView 和view 的区别
surfaceview：采用双缓冲技术，在单独的线程中更行界面
view：在ui线程中更新界面
12Android中进程的优先级？
前台进程，可见进程，服务进程，后台进程，空进程
13Android中那些情况会出现内存泄漏
内存泄漏的原因：当某个对象已经停止使用，本应该被回收，但是别的对象仍然持有该对象的引用，导致该对象部内被及时的回收，从而留在堆内存中，从而产生了内存泄漏。
内存泄漏的影响：oom，程序的崩溃。
①错误的使用单例模式

  public class AppManager {
    private static AppManager instance;
    private Context context;
    private AppManager(Context context) {
        this.context = context;
    }
    public static AppManager getInstance(Context context) {
        if (instance != null) {
            instance = new AppManager(context);
        }
        return instance;
    }
}

1、传入的是Application的Context：这将没有任何问题，因为单例的生命周期和Application的一样长
2、传入的是Activity的Context：当这个Context所对应的Activity退出时，由于该Context和Activity的生命周期一样长（Activity间接继承于Context），所以当前Activity退出时它的内存并不会被回收，因为单例对象持有该Activity的引用。
所以，正确的写法

public class AppManager {
    private static AppManager instance;
    private Context context;
    private AppManager(Context context) {
        this.context = context.getApplicationContext();
    }
    public static AppManager getInstance(Context context) {
        if (instance != null) {
            instance = new AppManager(context);
        }
        return instance;
    }
}

②handler使用造成

public class MainActivity extends AppCompatActivity {
    private Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            //...
        }
    };
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        loadData();
    }
    private void loadData(){
        //...request
        Message message = Message.obtain();
        mHandler.sendMessage(message);
    }
}

在这种情况之下，如果activity销毁，但是消息队列中还有未处理的message，message持有handler的引用，二handler持有activity的引用，造成了内粗泄漏。

public class MainActivity extends AppCompatActivity {
    private MyHandler mHandler = new MyHandler(this);
    private TextView mTextView ;
    private static class MyHandler extends Handler {
        private WeakReference<Context> reference;
        public MyHandler(Context context) {
            reference = new WeakReference<>(context);
        }
        @Override
        public void handleMessage(Message msg) {
            MainActivity activity = (MainActivity) reference.get();
            if(activity != null){
                activity.mTextView.setText("");
            }
        }
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mTextView = (TextView)findViewById(R.id.textview);
        loadData();
    }

    private void loadData() {
        //...request
        Message message = Message.obtain();
        mHandler.sendMessage(message);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mHandler.removeCallbacksAndMessages(null);
    }
}

创建一个静态Handler内部类，然后对Handler持有的对象使用弱引用，这样在回收时也可以回收Handler持有的对象，使用mHandler.removeCallbacksAndMessages(null);是移除消息队列中所有消息和所有的Runnable。当然也可以使用mHandler.removeCallbacks();或mHandler.removeMessages();来移除指定的Runnable和Message。

③线程造成的内存泄漏。

//——————test1
        new AsyncTask<Void, Void, Void>() {
            @Override
            protected Void doInBackground(Void... params) {
                SystemClock.sleep(10000);
                return null;
            }
        }.execute();
//——————test2
        new Thread(new Runnable() {
            @Override
            public void run() {
                SystemClock.sleep(10000);
            }
        }).start();

正确做法：

static class MyAsyncTask extends AsyncTask<Void, Void, Void> {
        private WeakReference<Context> weakReference;

        public MyAsyncTask(Context context) {
            weakReference = new WeakReference<>(context);
        }

        @Override
        protected Void doInBackground(Void... params) {
            SystemClock.sleep(10000);
            return null;
        }

        @Override
        protected void onPostExecute(Void aVoid) {
            super.onPostExecute(aVoid);
            MainActivity activity = (MainActivity) weakReference.get();
            if (activity != null) {
                //...
            }
        }
    }
    static class MyRunnable implements Runnable{
        @Override
        public void run() {
            SystemClock.sleep(10000);
        }
    }
  //——————
    new Thread(new MyRunnable()).start();
    new MyAsyncTask(this).execute();

④资源未关闭造成的内存泄漏
对于使用了BraodcastReceiver，ContentObserver，File，Cursor，Stream，Bitmap等资源的使用，应该在Activity销毁时及时关闭或者注销，否则这些资源将不会被回收，造成内存泄漏。