问：Serializable和Parcelable的区别
答：两者都是用来序列化数据的。Parcelable是AndroidSDK中的，也是google官方推荐在Android端使用的，效率会比Serializable高。
Serializable在序列化时，会产生大量的临时变量，从而引起JVM频繁的GC，效率比较低下。
Parcelable不能在需要将数据序列化存储到磁盘时使用，所以尽管Serializable效率低下一点，也应该使用Serializable。
使用Serializable只需要是实现Serializable即可，使用Parcelable需要实现Parcelable实现它的几个方法，AndroidStudio中有自动生成插件，几乎没自己写过。在使用Kotlin时，发现只需要注解即可：@Parcelize
@Parcelize
data class Goods(
val goodsId:String,
val goodsName:String
):Parcelable
使用IPC进程通信时，使用@Parcelize注解时发现Kotlin的一个bug： 目前问题跟踪在：Kotlin问题
//在AIDL生成.java文件时出现的一个问题：
if ((0!=_reply.readInt())) {
_result = com.xyx.studydemo.User.CREATOR.createFromParcel(_reply);
}
问：Intent和IntentFilter的区别及作用。
答：Android中通过Intent来进行消息传递，一个Intent对象表示一条消息，好比发送一封书信，包含有内容和收件地址，收件地址必须有，而内容不一定需要。Intent可以用来携带基本数据类型、String以及序列化的数据。通过Intent 可以实现各种系统组件的调用与激活.
IntentFilter: 可以理解为邮局或者是一个信笺的分拣系统。其中包含有：Action、Data、Category用来进行匹配，在manifest中配置。
问：讲述一下Handler机制及其原理
答：Handler机制是用于不同线程之间进行通信。Handler机制主要包含以下几个类：
Handler、Message、MessageQueue、Looper
他们之间的关系：Handler post 或者sendMessage（发送的Message）到MessageQueue，Looper不断的从MessageQueue中取出数据（loop），Message对象持有Handler的引用，回调给Handler。
Handler的使用：Handler需要在一个线程中（绑定一个线程 ThreadLocal）
new Thread(new Runnable() {
@Override
public void run() {
Looper.prepare(); //
Handler handler = new Handler();
Looper.loop();
}
}).start();
在子线程中如果不调用Looper.prepare的话，将会抛出异常：
Can't create handler inside thread that has not called Looper.prepare()
原因：
看看Handler的构造方法：
public Handler() {
this(null, false);
}
public Handler(Callback callback, boolean async) {
/**xxxxx一堆代码省略**/
mLooper = Looper.myLooper(); // 调用Looper.myLooper()，获得当前线程的Looper对象
if (mLooper == null) { // 如果没有Looper对象则会抛出异常
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue; // 存储当前线程Looper的MessageQueue对象
}
通过Looper.myLooper()获得当前线程的Looper对象时，没有找到当前线程的Looper对象，所以创建Handler时就抛出了异常。看看Looper的相关源码：
public static @Nullable Looper myLooper() {
return sThreadLocal.get(); // 从ThreadLocal对象中取出当前线程的Looper
}
//看看prepare()干的啥：
public static void prepare() {
prepare(true);
}
private static void prepare(boolean quitAllowed) {
if (sThreadLocal.get() != null) { // 如果当前线程已经有了Looper对象，再次调用prepare会抛出异常
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper(quitAllowed)); // 生成一个Looper对象，并与当前线程关联起来
}
Looper中的prepare方法是生成一个Looper对象添加到ThreadLocal中的。
这里可能抛出一个问题：可以在子线程中new Handler吗？
答：Handler的构造方法中从ThreadLocal中获取了一个Looper对象，如果获取不到Looper对象就会抛出一个异常。所以需要在new Handler之前将Looper对象存储到ThreadLocal中，也就是Looper.prepare()方法。主线程中可以直接new Handler()是因为主线程（ActivityThread）的main方法中调用了 Looper.prepareMainLooper();并且开启循环从MessageQueue中获取Message对象了。同时，从上面的源码中可以看到在同一个线程中不能多次调用prepare方法，否则会抛出异常。
创建了Handler对象后就可以发送Message对象了，来看看post、sendMessage方法源码：
//post
public final boolean post(@NonNull Runnable r) {
return sendMessageDelayed(getPostMessage(r), 0);
}
//sendMessage
public final boolean sendMessage(@NonNull Message msg) {
return sendMessageDelayed(msg, 0);
}
都是调用的sendMessageDelayed方法，我们来看一下：
//Handler类
//实际上 sendMessageDelayed方法最后调用到
public boolean sendMessageAtTime(@NonNull Message msg, long uptimeMillis) {
MessageQueue queue = mQueue; //Handler构造函数中的Looper对象获取的消息队列
if (queue == null) {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
return false;
}
return enqueueMessage(queue, msg, uptimeMillis);
}
private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
long uptimeMillis) {
msg.target = this; //给Message对象的target赋值，实际上就是Message持有了Handler的引用
//省略一堆代码.....
return queue.enqueueMessage(msg, uptimeMillis); //将Message加入到MessageQueue队列中
}
实际上：Handler发送消息后，将Message对象放入到了 MessageQueue这个消息队列中，Message对象中包含有Handler的对象实例。等待Looper循环取出。
就好比你把钱存到银行了，总不能不取出来花吧，来看看Handler机制如何把这个消息消费掉的：Looper.loop
//Looper类中
public static void loop() {
final Looper me = myLooper(); //与Handler中一样，获取同一个Looper对象
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
final MessageQueue queue = me.mQueue; //Looper对象持有了MessageQueue,用来获取队列中的Message对象
//省略一堆代码...
for (;;) { //开启一个死循环，不断获取Message对象进行分发
Message msg = queue.next(); // might block
if (msg == null) {
return;
}
// Make sure the observer won't change while processing a transaction.
final Observer observer = sObserver;
//省略一堆代码...
try {
msg.target.dispatchMessage(msg); //msg.target其实就是Handler的对象实例，稍后看Handler的dispatchMessage
//省略一堆代码...
} catch (Exception exception) {
//省略一堆代码...
} finally {
//省略一堆代码...
}
msg.recycleUnchecked(); //分发完毕后释放从MessageQueue中取出来的Message，此时对Handler的引用也就结束了。
//也就意味着Handler对Activity或其他类的引用也就结束了，可以回收了
}
}
实际上，Looper只负责从MessageQueue中取出Message消息对象，具体的分发还是Message中持有的Handler对象实例来做的 即：msg.target.dispatchMessage(msg); 我们来看看这个dispatchMessage(msg)方法：
/**
* Handle system messages here.
*/
public void dispatchMessage(@NonNull Message msg) {
if (msg.callback != null) { //判断这个Message对象是否有设置callback 有的进入到handleCallback
handleCallback(msg);
} else {
if (mCallback != null) { //判断Handler类中是否有Callback对象
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg); //调用Handler的handleMessage(msg)方法。
}
}
实际上，最后执行的一行方法 也是我们最为常用的，消息发送到了实例化Handler对象所在的线程（一般就是我们使用的主线程）。简单分析了一下Handler机制的几个主要的方法，总结一下：
1、实例化Handler对象前需要获取Looper的实例对象
2、Looper.prepare()方法将Looper的实例对象存入ThreadLocal中，Handler在实例化时从ThreadLocal中取出，这个方法只能调用一次
3、Handler对象发送一个Message对象到MessageQueue消息队列中，Message对象中包含有target，其实就是引用了Handler对象的实例
4、Looper.loop()方法中，开启无限循环从MessageQueue消息队列中取出Message对象，由Message对象的引用实例target(实际就是Handler)进行dispatchMessage分发消息，最后执行回到Handler中的handleMessage
5、经常说的Handler容易引起内存泄漏，实际上最为根本的原因是 Message持有了Handler、Handler持有了Activity，在Looper中从MessageQueue中取出Message后进行分发消费完成后就对Message对象进行了释放，这个时候Activity就没有什么引用它了，也就能被JVM回收了
问：为什么在Looper.loop()方法中开启了一个无限循环不会导致应用卡死？
答：应用程序不卡就是因为有looper一直在取消息，处理消息。造成卡死的原因是loop取出的消息长时间无法处理完成，导致其他消息无法及时响应造成的卡死现象。