Android面试题总结（一）

一.activity中切换屏幕生命周期的执行情况

1、不设置Activity的android:configChanges时，切屏会重新调用各个生命周期，切横屏时会执行一次，切竖屏时会执行两次

2、设置Activity的android:configChanges=”orientation”时，切屏还是会重新调用各个生命周期，切横、竖屏时只会执行一次

3、设置Activity的android:configChanges=”orientation|keyboardHidden“时，切屏不会重新调用各个生命周期，只会执行onConfigurationChanged方法

注意：自从Android 3.2（API 13），在设置Activity的android:configChanges=“orientation|keyboardHidden"后，还是一样会重新调用各个生命周期的。因为screen size也开始跟着设备的横竖切换而改变。因此，阻止程序在运行时重新加载Activity，除了设置"orientation”，你还必须加上"ScreenSize"。

从 Android 3.2 (API级别 13)开始：
1、不设置Activity的android:configChanges，或设置Activity的android:configChanges=“orientation”，或设置Activity的android:configChanges=“orientation|keyboardHidden”，切屏会重新调用各个生命周期，切横屏时会执行一次，切竖屏时会执行一次。
2、配置 android:configChanges=“orientation|keyboardHidden|screenSize”，才不会销毁 activity，且只调用 onConfigurationChanged方法。

设置屏幕方向：
静态：在 Manifest 设置 Activity 的android:screenOrientation，参数可选为unspecified、sensor、nosensor、user、lanscape、portrait 等等
动态：setRequestedOrientation（int requestedOrientation）

屏幕旋转中数据的保存：
重启 Activity 通过 onSaveInstanceState 和 onRestoreInstanceState 来处理：

@Overrideprotected
 void onSaveInstanceState(Bundle outState) { 
   Log.d(TAG," -- onSaveInstanceState"); 
   Log.d(TAG," -- onSaveInstanceState save: name = yoosir,age = 24,handsome = ture"); 
   outState.putString("name","yoosir"); 
   outState.putInt("age",24); 
   outState.putBoolean("handsome",true); 
   super.onSaveInstanceState(outState);
}
....
 @Overrideprotected
 void onRestoreInstanceState(Bundle savedInstanceState) { 
   super.onRestoreInstanceState(savedInstanceState); 
   Log.d(TAG," -- onRestoreInstanceState"); 
   if(savedInstanceState != null) { 
       String name = savedInstanceState.getString("name"); 
       int age = savedInstanceState.getInt("age"); 
       boolean isHandsome = savedInstanceState.getBoolean("handsome"); 
       Log.d(TAG, " -- onRestoreInstanceState get: name = " + name + ",age = " + age + ",handsome = " + isHandsome); 
   }}

不重启 Activity 靠的是 onConfigurationChanged 来处理：

@Overridepublic void onConfigurationChanged(Configuration newConfig) { 
   super.onConfigurationChanged(newConfig); 
   Log.d(TAG," -- onConfigurationChanged"); 
   if(newConfig.orientation == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT){ 
       //切换到竖屏  
      //修改布局文件  
      setContentView(R.layout.activity_main);  
      //findViewById ....   
     //TODO something  
      Log.d(TAG," -- onConfigurationChanged  可以在竖屏方向 to do something"); 
   }else{  
      //切换到横屏  
      //修改布局文件  
      setContentView(R.layout.activity_main);  
      //findViewById ....  
      //TODO something  
      Log.d(TAG," -- onConfigurationChanged  可以在横屏方向 to do something"); 
   }
}

如果我们应用是手机和平板都可用的，且手机的只能是竖屏不可切换，平板的只能是横屏不可切换。首先，我们要区分设备是手机还是平板，然后设置屏幕方向。代码如下：

/**
 * 判断是否平板设备
 * @param context
 * @return true:平板,false:手机 
*/
private boolean isTabletDevice(Context context) {
    return (context.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) >= Configuration.SCREENLAYOUT_SIZE_LARGE;
}

具体详见
Android 横竖屏切换
其他：
Android视频播放器实现小窗口和全屏状态切换

二、Service是运行在哪个线程，如何启动或者停止，它是和activity怎么交互的。

1.一个service在它的主线程中运行。也就是说如果你在Service里编写了非常耗时的代码，程序必定会出现ANR的。Service作为Android四大组件之一，在每一个应用程序中都扮演着非常重要的角色。它主要用于在后台处理一些耗时的逻辑，或者去执行某些需要长期运行的任务。必要的时候我们甚至可以在程序退出的情况下，让Service在后台继续保持运行状态。运行于后台并不意味着运行于子线程，这点要注意。

2.启动通常有两种：
Service通常采用两种方式：

被启动（started）：

当一个应用程序组件通过调用startService()启动它时，这个service称

为”started”。一旦被启动，一个service就可以在后台独立的运行，即使启动

它的组件已经被destory。通常一个被启动的service执行一项单独的操作并为

呼叫者（caller）返回结果。比如说，它或许通过网络下载或上传一个文件。当

操作完成时，这个service将自动停止。

被绑定（bound）：

当一个应用程序组件通过调用bindService()绑定到它上面时，这个service

称为” bound”。一个绑定的service提供了一个客户-服务接口来允许这个组件

与service交互，发送请求，获得结果甚至使用进程间通信来跨进程做这些。一

个绑定的service一直运行直到有其他的组件绑定到它上面。多个组件可以一次

性绑定到一个service，但是当它们全部都`解绑`了，service将被销毁。

只取决于你是否实现了一对回调函数：onStartCommand()来允许组件启动它以及onBind()允许绑定。在manifest中声明，利用intent启动。
可以为service单独为耗时操作创建新线程，然后主线程依然可以将重心放在用户与activity的交互上面，而且能防止ANR.

停止：service必须调用stopSelf()停止自己或由另一个组件调用stopService()来停止它．一旦通过stopSelf()或stopService()发出了停止请求，系统就会尽可能快地销毁service．

与activity的交互：
调用bindService()方法将Activity和Service进行绑定。首先创建了一个ServiceConnection的匿名类，在里面重onServiceConnected()方法和onServiceDisconnected()方法，这两个方法分别会在Activity与Service建立关联和解除关联的时候调用。在onServiceConnected()方法中，又通过向下转型得到了Binder（service中的binder)的实例，有了这个实例，Activity和Service之间的关系就变得非常紧密了。现在我们可以在Activity中根据具体的场景来调用Binder中的任何public方法，即实现了Activity指挥Service干什么Service就去干什么的功能。
解除关联时只需要unbindService即可。

如何才能让Activity与一个远程Service建立关联呢？这就要使用AIDL来进行跨进程通信了（IPC）
AIDL（Android Interface Definition Language）是Android接口定义语言的意思，它可以用于让某个Service与多个应用程序组件之间进行跨进程通信，从而可以实现多个应用程序共享同一个Service的功能。

但是在另一个应用程序中去绑定Service的时候并没有MyService这个类，这时就必须使用到隐式Intent了。现在修改AndroidManifest.xml中的代码，给MyService加上一个action，指定响应的service

一个Service必须要在既没有和任何Activity关联（unbind)又处于停止状态（stop)的时候才会被销毁。
该始终记得在Service的onDestroy()方法里去清理掉那些不再使用的资源，防止在Service被销毁后还会有一些不再使用的对象仍占用着内存。

拓展：service和thread没有任何关系
既然在Service里也要创建一个子线程，那为什么不直接在Activity里创建呢？这是因为Activity很难对Thread进行控制，当Activity被销毁之后，就没有任何其它的办法可以再重新获取到之前创建的子线程的实例。**而且在一个Activity中创建的子线程，另一个Activity无法对其进行操作。但是Service就不同了，所有的Activity都可以与Service进行关联，然后可以很方便地操作其中的方法，即使Activity被销毁了，之后只要重新与Service建立关联，就又能够获取到原有的Service中Binder的实例。**因此，使用Service来处理后台任务，Activity就可以放心地finish，完全不需要担心无法对后台任务进行控制的情况。

**

三、handler机制的原理

与Windows系统一样，Android也是消息驱动型的系统。
引用一下消息驱动机制的四要素：

• 接收消息的“消息队列”
• 阻塞式地从消息队列中接收消息并进行处理的“线程”
• 可发送的“消息的格式”
• “消息发送函数”

与之对应，Android中的实现对应了

• 接收消息的“消息队列” ——【MessageQueue】
• 阻塞式地从消息队列中接收消息并进行处理的“线程” ——【Thread+Looper】
• 可发送的“消息的格式” ——【Message】
• “消息发送函数”——【Handler的post和sendMessage】

其中每一条线程只有一个消息队列MessageQueue, 消息的入队是通过 MessageQueue 中的 enqueueMessage() 方法完成的, 消息的出队是通过Looper 中的loop()方法完成的.

Andriod提供了 Handler 和 Looper 来满足线程间的通信。一般的做法是在子线程里获取主线程里的Handler对象，然后通过该对象向主线程的消息队列里发送消息，进行通信。
如果子线程想修改主线程的UI，可以通过发送Message给主线程的消息队列，主线程经行判断处理再对UI经行操作。

在源码中，这个过程是这么体现的。
Looper中主要有两个方法，prepare( )和loop( ); prepare( )生成了一个本地线程的Mylooper,而loop( )中则通过这个Mylooper得到了messageQueue，从而保证prepare( )在loop( )前实现，一个线程只有一个looper,对应一个messageQueue; 进入无限循环loop( )，取出消息，如果无消息就阻塞，有消息，就使用msg.target.dispatchMessage(msg),将消息交给msg的target(其实就是handler对象)在dispatchMessage方法去处理，dispatchMessage里面有一个空方法handleMessage,这是因为消息的最终回调形式是由我们控制的。所以在创建hander的时候是都是复写handleMessage方法，然后根据msg.what进行消息处理的。

为什么无限循环不会卡死程序：
其实前面在点击事件中无限循环打印日志的例子已经很好的说明了我们的问题。之所以运行死循环不会导致ANR, 而在自循环以后触摸屏幕却出发了ANR, 原因就是因为耗时操作本身并不会导致主线程卡死, 导致主线程卡死的真正原因是耗时操作之后的触屏操作, 没有在规定的时间内被分发。其实这也是我们标题索要讨论的Looper 中的 loop()方法不会导致主线程卡死的原因之一。

”Looper.loop()的阻塞“和”UI线程上执行耗时操作卡死“的区别：

• 首先这两之间一点联系都没有，完全两码事。
• Looper上的阻塞，前提是没有输入事件，MsgQ为空，Looper空闲状态，线程进入阻塞，释放CPU执行权，等待唤醒。（这个就和 epoll 有关了）
• UI耗时导致卡死，前提是要有输入事件，MsgQ不为空，Looper正常轮询，线程并没有阻塞，但是该事件执行时间过长（5秒？），而且与此期间其他的事件（按键按下，屏幕点击…）都没办法处理（卡死），然后就ANR异常了

所以说：卡死是指不响应消息，而那个循环就是一个消息处理循环啊。

Android中的Thread, Looper和Handler机制(附带HandlerThread与AsyncTask)

主线程中的Looper.loop()一直无限循环为什么不会造成ANR？
四、activity的生命周期是哪些，哪些可见，哪些不可见

创建 onCreate - 启动onStart – 恢复 onResume – 暂停 onPause – 结束 onStop – 销毁onDestroy

一个Activity可见的生命周期始于OnStart调用，结束于OnStop调用。在这两个方法中间，Actvity将会对用户是可见的，尽管它可能没有焦点，也可能部分被遮挡着。

透明 Activity 的生命周期（SecondActivity 是透明的，可以看到 MainActivity 没有调用 onStop）：
2019-09-17 20:49:18.643 30128-30128/com.test.testkotlin E/main: onCreate
2019-09-17 20:49:18.646 30128-30128/com.test.testkotlin E/main: onStart
2019-09-17 20:49:18.655 30128-30128/com.test.testkotlin E/main: onresume
2019-09-17 20:49:24.876 30128-30128/com.test.testkotlin E/main: onpause
2019-09-17 20:49:24.898 30128-30128/com.test.testkotlin E/second: onCreate
2019-09-17 20:49:24.907 30128-30128/com.test.testkotlin E/second: onStart
2019-09-17 20:49:24.911 30128-30128/com.test.testkotlin E/second: onResume
2019-09-17 20:49:41.558 30128-30128/com.test.testkotlin E/second: onPause
2019-09-17 20:49:41.592 30128-30128/com.test.testkotlin E/main: onresume
2019-09-17 20:49:41.624 30128-30128/com.test.testkotlin E/second: onStop
2019-09-17 20:49:41.625 30128-30128/com.test.testkotlin E/second: onDestroy

onRestart的调用场景
（1）按下home键之后，然后切换回来，会调用onRestart()。
（2）从本Activity跳转到另一个Activity之后，按back键返回原来Activity，会调用onRestart()；
（3）从本Activity切换到其他的应用，然后再从其他应用切换回来，会调用onRestart()；
五、简述Android应用程序结构是哪些?

**
Android应用程序结构是：
Linux Kernel(Linux内核)、Libraries(系统运行库或者是c/c++核心库)
Application Framework(开发框架包)、Applications (核心应用程序)

**

六、Android的数据存储方式有哪几种

**
Android提供了5种方式存储数据：
（1）使用SharedPreferences存储数据；它是Android提供的用来存储一些简单配置信息的一种机制，采用了XML格式将数据存储到设备中。只能在同一个包内使用，不能在不同的包之间使用。
（2）文件存储数据；文件存储方式是一种较常用的方法，在Android中读取/写入文件的方法，与Java中实现I/O的程序是完全一样的，提供了openFileInput()和openFileOutput()方法来读取设备上的文件。
（3）SQLite数据库存储数据；SQLite是Android所带的一个标准的数据库，它支持SQL语句，它是一个轻量级的嵌入式数据库。
（4）使用ContentProvider存储数据；主要用于应用程序之间进行数据交换，从而能够让其他的应用保存或读取此Content Provider的各种数据类型。
（5）网络存储数据；通过网络上提供给我们的存储空间来上传(存储)和下载(获取)我们存储在网络空间中的数据信息。

**

七、抽象类abstract class和接口有什么区别

**

可以从两方面来理解：
**应用上：**接口更多的是在系统架构设计方法发挥作用，主要用于定义模块之间的通信契约，从而降低耦合；抽象类在代码实现方面发挥作用，可以实现代码的重用，例如，模板方法设计模式是抽象类的一个典型应用，假设某个项目的所有Servlet类都要用相同的方式进行权限判断、记录访问日志和处理异常，那么就可以定义一个抽象的基类，让所有的Servlet都继承这个抽象基类，在抽象基类的service方法中完成权限判断、记录访问日志和处理异常的代码，在各个子类中只是完成各自的业务逻辑代码
语法上：
1.抽象类可以有构造方法，接口中不能有构造方法。
2.抽象类中可以有普通成员变量，接口中没有普通成员变量
3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
4. 抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。
5. 抽象类中可以包含静态方法，接口中不能包含静态方法
6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。
7. 一个类可以实现多个接口，但只能继承一个抽象类。
8. 抽象类不能够实例化

1、抽象类里面可以有非抽象方法，但接口里只能有抽象方法
声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽像构造函数或抽像静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。

2、接口（interface）是抽象类的变体。在接口中，所有方法都是抽像的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽像的，没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对像上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口