准备
1、Android 基础面试 https://www.jianshu.com/p/ffe7e0561c85?tdsourcetag=s_pcqq_aiomsg（还须要总结知识）html
https://blog.csdn.net/songzi1228/article/details/99975018 （多线程的总结）java
https://www.jianshu.com/p/90db19b4c98a （大佬的博客园来观看使用）web
1.Activity异常的生命周期处理 面试
@Override
public void onSaveInstanceState(Bundle outState, PersistableBundle outPersistentState) {
super.onSaveInstanceState(outState, outPersistentState);
}
@Override
protected void onRestoreInstanceState(Bundle savedInstanceState) {
super.onRestoreInstanceState(savedInstanceState);
}
异常或者系统内存不足会调用该方法
2.Fragment的生命周期
Fragment的生命周期算法
3.SingleTask的启动模式数据库
能够将不一样的APP的activity中设置为相同的taskAffinity，虽然在两个应用当中可是他们会被分配到同一个Task中编程
4. View的事件分发机制数组
2、异步消息处理机制浏览器
1. 主线程中调用Loop，那么为何没有形成阻塞呢?
ActivityThread的Main方法里面有个Loop的消息队列,ActivityThread 有个 getHandler 方法，获得这个 handler 就能够发送消息，而后 loop 里就分发消息，而后就发给 handler, 缓存
而后就执行到 H（Handler ）里的对应代码。因此说ActivityThread的main方法主要就是作消息循环，一旦退出消息循环，那么你的程序也就能够退出了，因此这些代码就不会卡死。
2. AsyncTask
1). 组成：线程池＋Handler
2). Sting : 指的是doInBackgroud的参数类型
String : 指的是onProgressUpdate的参数类型
Long : 指的是onPostExecute的方法的参数以及doInBackground的返回参数
public class AsynctaskText extends AsyncTask<String , String , Long>{
/**
* 运行在UI线程中，在调用doInBackground以前运行的,能够作一些控件初始化
*/
@Override
protected void onPreExecute() {
super.onPreExecute();
}
/**
*后台运行的方法，运行在非ui线程中，能够执行耗时操做
*/
@Override
protected Long doInBackground(String... strings) {
return null;
}
/**
*在doBackground里面会执行onProgressUpdate这个函数
*/
@Override
protected void onProgressUpdate(String... values) {
super.onProgressUpdate(values);
}
/**
*运行在ui线程，在doInBackground以后去执行的，
*/
@Override
protected void onPostExecute(Long integer) {
super.onPostExecute(integer);
}
@Override
protected void onCancelled() {
super.onCancelled();
}
}
execute和executeOnExecutor的区别
execute : Execute方法是串行执行，须要一个一个去执行
executeOnExecutor : 并行执行,须要添加线程池参数, 任务能够同步进行
3、VIew绘制相关知识
1. window、surface、decorview
window : 是对咱们Android系统当中窗口的一种抽象类,PhoneWindow是Window窗口的一个实现类。
DecorView : 是咱们应用窗口的一个根容器（本质上是一个FreamLayout）,主要包含两个参数TitleView 和 ContentView
surface : 是窗口独占一个surface的写实区域
3. ListView滑动时候为何不会发生OOM的缘由（RecycleBin的机制） : 将离开屏幕外的view删除而且存放到RecycleBin这个类里面,当准备展现下一个view的时候，它会从RecycleBin里面取出一个scrapView，而后就将它设置为converVIew的参数进行判断是否已经设置过，从getView里面有这个方法从而到达view复用的做用
4.ListView的性能优化５个优化点：
1). converView
2).viewHolder
3).getVIew尽可能少作耗时的操做(当滑动中止时候再去加载图片)
4).ListVIew中的item元素避免半透明
5).开启硬件加速
4、 异常与性能
1. 如何产生ANR
a). View的按键或者触摸事件在5秒没有获得回应
b). BroadcastReciver的onReceive()函数运行在了主线程中，在10秒内没法完成处理
c).Service的各个生命周期函数在20秒内没法完成处理
2. 如何解决ANR
a). 使用AsyncTask处理IO的耗时操做
b). 使用Thread或者HandlerThread提供异步操做
c). 使用Handler来处理工做线程的耗时操做
d). Activity里面的全部生命周期都是在主线程中，避免写大量的耗时操做
3. OOM容易混淆的概念
内存溢出：咱们申请的内存已经超出虚拟机的最大内存的限度就会抛出Out Of memory
内存抖动 : 短期大量的对象被建立而后就释放，触发的GC机制，严重占用内存区。
内存泄露 : 咱们要回收的对象没法进行GC的回收操做
4. bitmap的讲解
(1).Bitmap的模型: Android 2.3.3以前，Bitmap的像素数据存放在Native内存，而Bitmap对象自己则存放在Dalvik Heap中。而在Android3.0以后，Bitmap的像素数据也被放在了Dalvik Heap中。
(2).在Android2.3.3以前推荐使用Bitmap.recycle()方法进行Bitmap的内存回收; 在Android3.0以后更注重对Bitmap的复用
(3). recycle 的方法: 它既回收JAVA的内存也回收native的内存,这个对象之后就不会再被调用了。当你没有对象时候就会有GC去回收它，建议不要主动去调用它(快速截屏)
(4).inBitmap参数的好处 : 前提是旧的inBitmap大小>=新的inBitmap的大小，不然不能复用。
(5). LRU的算法 : 内部使用LinkedHashMap做为缓存, get和put完成添加和获取的操做，HashMap的remove方法来移除对象,当内部缓存满的时候，会调用trimToSize把较早或者使用最少的缓存对象移除出去，添加新的对象。
(6). 三级缓存 : 网络－>本地->内存
原理：第一次打开app时候，图片首先从网络得到，而后再本地和内存各缓存一份，再去请求相同的url的时候，就会去本地或者内存去找
(7). 图片产生OOM的缘由
a.一个页面加载过多图片
b. 加载图片没有进行对图片尺寸、质量进行压缩
c.加载大量图片时候作图片缓存
(8) . 图片的种类
PNG : 无损压缩格式，支持透明通道
JPEG : 有损压缩格式，不支持透明通道
WEBP : 既支持有损压缩也支持无损压缩，也支持透明通道
GIF : 支持多帧动画
(9). 超大图片加载方案
可使用BitMapRegionDecoder
5. UI卡顿的讲解
1). UI卡顿缘由分析
(1).在UI线程中作轻微的耗时操做，致使UI卡顿
(2).布局Layout过于复杂，没法在16ms内完成渲染（从布局上），可使用include、merage、view-stub这样标签做为处理,布局过于复杂使用自定义view
(3).同一时间动画执行次数太多，致使CPU或GPU负载太重
(4).View的过分绘制，致使某些像素在同一帧时间内过分绘制屡次,从而让CPU或者GPU太重(从代码上) ----->自定义view使用clipRect来屏蔽被遮盖的view绘制
(5).冗余的资源或者逻辑致使加载过慢
(6).避免在onDraw里面执行对象的建立（这样会产生内存抖动）
(7).图片显示（监听ListView滑动时候，就不要加载图片，当监听到中止时候，再去加载图片）
6.常见内存泄露案例
1.单例：长生命周期的对象(Application的对象)持有短生命周期的对象(是指Activity的对象)---->解决getApplicationContext()
2. handler : 非静态内部类持有外部类的引用，致使于没法释放外部类的对象---->解决方法将handler至于为static的对象，而后将外部类改成弱引用来使用
3.线程引发: AsyncTask和Runnable使用匿名内部类，由于非静态内部类持有外部类的引用，和handler相似
4.文件的读写、数据库网络启用后没有关闭
5.注册广播没有关闭广播
7.内存管理
(1).分配机制
(2).回收机制
五大进程：前台进程、可见进程、服务进程、后台进程、空进程
(3).内存优化
当Service完成任务后，尽可能中止它(可使用IntentService)----->它是在异步线程中执行的，用完后它会自动释放对象的
避免滥用Bitmap致使内存的浪费
尽可能少使用枚举常量，可使用注解方法
使用多进程来分担主内存耗时
8.冷启动优化
5、开源框架的学习
1.AOP的切面编程(目前做为了解使用)
(1).注解使用先关介绍
@Before 前置通知，至关于BeforeAdvice
@AfterReturning 后置通知，至关于AfterReturningAdvice
@Around 环绕通知，至关于MethodInterceptor
@AfterThrowing抛出通知，至关于ThrowAdvice
@After 最终final通知，无论是否异常，该通知都会执行
@DeclareParents 引介通知，至关于IntroductionInterceptor (了解)
(2). JoinPoint 链接点对象能够得到参数讲解
目标对象：getTarget()
得到方法签名：getSignature()
得到方法名称：getSignature().getName()
得到实际参数：getArgs()
得到当前指定方法的类型：getKind()
案例1：性能监控
@Aspect
public class PerformanAop {
@Around("call(* com.example.mi.okhttp.MainActivity.**(..))")
public void getTime(ProceedingJoinPoint joinPoint){
Signature signature = joinPoint.getSignature();
String name = signature.toShortString();
long time = System.currentTimeMillis();
try {
joinPoint.proceed(); ----------------->执行该程序的方法
} catch (Throwable throwable) {
throwable.printStackTrace();
}
Log.d("ceshi", name + "=" + (System.currentTimeMillis() - time));
}
}
2.MVC的架构的介绍
Ｃ层 : 页面和数据交互，耦合程度高，不利于解耦
3.MVP的架构介绍
MVP的特色:
Presenter彻底将Model和View解耦，主要逻辑处于Presenter中；Presenter和具体View没有直接关联，都是经过接口进行交互。
View变动时候，能够保持Presenter不变，因此Model和View已经彻底解耦
MVP的优势:
低耦合：Model、VIew层的变换不回影响到对方
可重用性:Model层可用于多个View
方便测试:能够单独多Model和VIew层单独测试
MVP的缺点:
当有一个很大的复杂页面，这样接口机会新增长不少接口，致使维护成本很大。
解决方法：把一些通用的接口做为基类，其余接口去继承
4.MVC和ＭVP流程的大体区别
５．MVVM的数据模型
MVVM的特色:
ViewModel和Model/View进行双向绑定,View 发生改变时候，ViewModel会通知Model更新数据；Model数据更新时候，ViewModel会通知View更新显示
6.插件化模型(学习反射)主要解决
(1).动态加载 DexClassLoader、PathClassLoader学习(动态加载app)
(2).动态加载资源文件 AssetManager 动态加载资源文件
(3).代码的加载
7.热修复模型
(1).Android 类加载机制
PathClassLoader : 加载内存中已经安装的apk中的dex
DexClassLoader : 加载sd卡中的apk/jar
(2).热修复机制(经过向dexElements数组插入dex来完成热修复)
dexElements数组、ClassLoader会遍历dexElements这个数组
原理：dexElements数组会在基类的BaseClassLoader中创造好,DexClassLoader和PathClassLoade
都是继承BaseClassLoader这个类的，经过ClassLoader去遍历ｄｅｘElements数组，加载这个数组
dex文件，若是BaseClassLoader加载到正确的dex文件后，就不会再去加载有crash的dex文件了，
把正确的dex文件排在dexElements数组前面便可。
８．进程保活的实现
(1)．Android的进程优先级：前台优先级、可见进程、服务进程、后台进程、空进程(主要为了作缓存、缩短下次启动时间)
(2).进程保活方案
a.利用系统广播拉活
缺点：当只有在特定场景下才能够拉起保活，下次被杀死后，没法获得控制
b.利用系统Service机制拉活 : onStartCommand方法，返回START_STICKY
缺点：在短期内被屡次杀死就不会被拉活、被root或者其余工具被stop也是没法拉活的
c.经过native进程拉活(经过AMS的进程杀死)
d.进程相互唤醒（打开一个app同时唤醒另外一个app）
e.提高Service进程优先级，好比改成前台进程 startForeground(1,notification)
f.JobScheduler用来检测你本身的服务是否被杀掉，若是被杀掉了，你重启本身的服务 缺点：须要有自启动权限
6、Java基础面试
１．synchronized(悲观锁)和lock的区别
synchronzied 同步代码块底层原理 : monitorenter指向同步代码块的开始位置，monitorexit指向同步代码块的结束位置
线程执行到monitorenter指令时，该线程对象持有锁，即线程得到monitor持有权，count计数器+1,得到线程锁
线程执行完毕后，执行monitorexit执行指令，count为0，释放锁。 注意：不管是正常结束仍是异常结束，都会执行monitorexit指令
synchronized 的同步方法的底层原理 : ACC_SYNCHRONIZED的flag标记该方法是不是同步方法，从而执行相应的同步调用
２．sleep和wait(notify)区别
sleep是Thread的内部的一个静态方法，能够再任何地方调用；wait是Object成员方法，只能在synchroized代码中被调用，其余地方调用会非法监控异常
在等待时候,wait是释放锁的，用于线程交互；sleep会一直持有锁，不会改变锁的状态，用于线程切换cpu的状态
3.lock、synchronized 和 volatile的区别
synchronized 和 volatile 的区别
volatile只能在线程内存和主内存之间存一个变量值，synchronized能够修饰类、对象、方法等，可是synchronized很消耗内存
volatile的理解:具备可见性、有序性，不具有原子性、禁止指令重排。 volatile修饰的变量会强制把数值写入主内存中
synchronized 和 lock 的区别
synchronized是Java的关键字，Lock是接口
synchronized是自动释放锁，Lock须要手动释放锁，因此写到try catch中而且在finally中释放锁
synchronized没法中断等待的锁，Lock能够中断，它能够在激烈的读写操做
4.线程池工做流程：
(1).首先判断线程池是否已经满了
(2).其次是判断工做队列是否已经满了
(3).最后判断整个线程池是否满了
五种线程池、四种拒绝策略、三种阻塞队列
五种线程池
threadPool = Executors.newCachedThreadPool(); //有缓冲的线程池，线程数 JVM 控制
threadPool = Executors.newFixedThreadPool(3); //固定大小的线程池,支持线程池并发
threadPool = Executors.newScheduledThreadPool(2); //固定大小的线程池，支持定时或者周期执行任务
threadPool = Executors.newSingleThreadExecutor(); //单线程的线程池，只有一个线程在工做
threadPool = new ThreadPoolExecutor(); //默认线程池，可控制参数比较多
四种拒绝策略
rejected = new ThreadPoolExecutor.AbortPolicy(); //默认，队列满了丢任务抛出异常
rejected = new ThreadPoolExecutor.DiscardPolicy(); //队列满了丢任务不异常
rejected = new ThreadPoolExecutor.DiscardOldestPolicy(); //将最先进入队列的任务删，以后再尝试加入队列
rejected = new ThreadPoolExecutor.CallerRunsPolicy(); //若是添加到线程池失败，那么主线程会本身去执行该任务
三种阻塞队列
有限队列
ArrayBlockingQueue<>(5); //基于数组的先进先出队列，有界
SynchronousQueue<>(); //无缓冲的等待队列，无界 适用于newCachedThreadPool线程池
无限队列
LinkedBlockingQueue<>(); //基于链表的先进先出队列，无界 适用于newFixedThreadPool、newScheduledThreadPool
参数讲解:
* corePoolSize：核心线程池大小
* maximumPoolSize：最多线程池大小
* keepAliveTime：表示空闲线程的存活时间
* unit：keepAliveTime时间单位
* workQueue：阻塞任务队列
* threadFactory：新建线程工厂
* RejectedExecutionHandler：保护策略
5.throw和throws的区别
throw : 用在方法体内，跟的是对象名，throw抛出异常，必定会抛出某种异常
throws : 用在方法后面，跟的是类名，它抛出的异常只是一种可能性，并不必定会抛出异常的
6.final、finalize、finally的关键字的区别
final : 修饰符，能够修饰类,不能再派生新的子类也不能做为父类被继承 ； 能够修饰变量，该变量的数值就不能修改
finally : try ... catch 语句中使用
finalize : 在垃圾回收时候使用，被清理对象没有被引用的状况下调用的。
7.注解相关介绍
1.Retention : 定义注解保留的时间
RetentionPolicy.SOURCE 注解只保留在源码，在编译器进行编译时会被忽略
RetentionPolicy.CLASS 注解由编译器保存在class文件中，但不须要在运行时由VM保留，没法经过反射读取，这是默认的策略。
RetentionPolicy.RUNTIME 注解由编译器保存在class文件中，并在运行时由VM保留，能够经过反射读取。
2.Target : 修饰对象的范围
ElementType.TYPE：容许被修饰的注解做用在类、接口和枚举上
ElementType.FIELD：容许做用在属性字段上
ElementType.METHOD：容许做用在方法上
ElementType.PARAMETER：容许做用在方法参数上
ElementType.CONSTRUCTOR：容许做用在构造器上
ElementType.LOCAL_VARIABLE：容许做用在本地局部变量上
ElementType.ANNOTATION_TYPE：容许做用在注解上
ElementType.PACKAGE：容许做用在包上
8.触发GC的条件
(1). 当应用程序空闲时，即没有应用线程再运行时，GC会被调用的
(2). JAVA内存不足的时候，GC会被调用
9. 减小GC的开销措施
(1). 不要显示调用System.gc()
(2).尽可能减小建立临时对象(至关于减小垃圾的产生，从而延长第二次GC的触发时间)，对象不用时候最好显示设置为null(有利于GC收集器断定垃圾，从而提升垃圾回收)
(3). 尽可能使用StringBuffer，而不用String来增长字符串
(4). 能使用基本变量就不用封装好的对象(好比int ---> Integer对象)
(5). 尽可能减小使用静态变量（静态变量属于全变量，不会被GC回收掉，他们也会一直占用内存，增长GC的次数）
10.终止线程的方法
1.ｗｈｉｌｅ(ｂｏｏｌｅan 变量值去终止) ------> 可是不会被当即终止线程
2.while(!Thread.interrupted())---------->判断是否执行Thread.interrupted这个方法,执行以后必定在try..catch..中的catch方法中执行return,这样才能够真正中断该方法
3. while(flag && ! Thread.interrupted()) ----->这两个方法去真正执行中断程序
private volatile boolean flag = false
11.多线程优化
将非UI线程设置线程等级，通常下载线程Thread.setThreadPriority(Processs.THREAD_PRIORITY_BACKGROUND);
7、网络相关的知识
1.http和https的区别
HTTPS协议须要到CA申请证书，通常免费证书不多，须要交费。
HTTP协议运行在TCP之上，全部传输的内容都是明文，HTTPS运行在SSL/TLS之上，SSL/TLS运行在TCP之上，全部传输的内容都通过加密的。
HTTP和HTTPS使用的是彻底不一样的链接方式，用的端口也不同，前者是80，后者是443。
HTTPS能够有效的防止运营商劫持，解决了防劫持的一个大问题。
２. http1.0、http1.1和http2.0区别
http1.0 1.0+ : 支持版本号、请求头、代理链接
http1.1 : 默认持久链接、支持缓存、支持管道方法发送多个请求 (一个TCP只能链接一个HTTP，不能复用；只能单向请求方式)
http2.0 : 支持多路复用，能够设定请求的优先级；支持双向通讯；去除不须要的HTTP请求头，减小网络带宽
３．Http的请求方式
常见如下四种：
get : 获取资源
post : 建立资源
put : 更新资源
delete : 删除资源
4.get和post的区别
url可见性 : get的url可见(不安全) post的url参数不可见（安全）
数据传输上 : get经过拼接url进行传递参数 post经过body体传输参数
缓存性： get请求是能够缓存的 post请求不能够缓存
后退页面的反应 : get请求页面后退时，不产生影响 post请求页面后退时，会从新提交请求
传输数据的大小 : get通常传输数据大小不超过2k-4k post请求传输数据的大小能够本身，也能够无限大
5. cookie和session的区别
存放位置不一样：cookie存放在客户端，session存放在服务端的
存取方式不一样 : cookie用键值对，session能够保存任何内容
安全性 : cookie保存在客户端，因此安全性比session低
有限期不一样 : cookie能够设置时间，session则不能
set-cookie:[expires过时、到期)=new.Date(Date.now() +10 *1000)] 10S后过时,若是不设置默认是关闭浏览器当即失效
对服务器压力不一样 : 处于高并发状况下，cookie比session要高，由于它是保存在客户端的
6.输入URL后HTTP请求返回完整的过程
7.网络模式
8.三次握手的过程
SYN(synchronous创建联机) ACK(acknowledgement 确认) Sequence number(顺序号码)
第一次握手：主机A发送位码为syn＝1，随机产生seq number=1234567的数据包到服务器，主机B由SYN=1知道，A要求创建联机；
第二次握手：主机B收到请求后要确认联机信息，向A发送ack number=(主机A的seq+1)，syn=1，ack=1，随机产生seq=7654321的包；
第三次握手：主机A收到后检查ack number是否正确，即第一次发送的seq number+1，以及位码ack是否为1，若正确，主机A会再发送ack number=(主机B的seq+1)，ack=1，主机B收到后确认seq值与ack=1则链接创建成功。
4.四次挥手
FIN (但愿断开链接) ACK(acknowledgement 确认) Sequence number(顺序号码)
5.三次握手和四次挥手的面试点
为何不能用两次握手进行链接
三次握手是为了确保双方都已经进入准备好的状态，能够进行通讯，而两次握手的建立可能形成死锁
假如：当C给S发一个链接请求，而后把C一个应答，这时候S已经认为建立成功了，可是C认为尚未建立成功，将忽略S那边发来的数据，还在等待应答中，S发出的分组超时后，
再次发送请求,这样就会造成死锁
若是已经创建了链接，可是客户端忽然出现故障了怎么办？
TCP还设有一个保活计时器，显然，客户端若是出现故障，服务器不能一直等下去，白白浪费资源。服务器每收到一次客户端的请求后都会从新复位这个计时器，
时间一般是设置为2小时，若两小时尚未收到客户端的任何数据，服务器就会发送一个探测报文段，之后每隔75秒钟发送一次。若一连发送10个探测报文仍然没反应，
服务器就认为客户端出了故障，接着就关闭链接。
6.TCP和UDP的区别
a.基于链接与无链接；
b.对系统资源的要求（TCP较多，UDP少）；
c.UDP程序结构较简单；
d.流模式与数据报模式 ；
e.TCP保证数据正确性，UDP容易丢包；TCP保护数据的顺序，UDP不行 UDP应用于IP电话和实时视频会议
7.Http请求协议的讲解
8.请求头的常见属性详解
User-Agent : 向服务器请求的操做系统以及版本号等
Referer : 你当前网页的上一个地址
Cache-Control : 缓存
Connection : 链接的类型(长链接)
Range : 多线程取舍时候，截取某一个字段
If-Match :
If-Modified-Since :
If-None-Match :
9.响应头的讲解
Cache-Control : 缓存
Content-Encoding : gzip 编码格式： 压缩
Content-Type : text/html 直接的文本、html类型
响应码 : 100-199 信息提示
200-299 成功
300-399 重定向
400-499 客户端错误
500-599 服务端错误
8、自定义注解的学习
@Retention：注解的保留位置
@Retention(RetentionPolicy.SOURCE) //注解仅存在于源码中，在class字节码文件中不包含
@Retention(RetentionPolicy.CLASS) // 默认的保留策略，注解会在class字节码文件中存在，但运行时或者反射都没法得到，
@Retention(RetentionPolicy.RUNTIME) // 注解会在class字节码文件中存在，在运行时能够经过反射获取到
@Target:注解的做用目标
@Target(ElementType.TYPE) //接口、类、枚举、注解
@Target(ElementType.FIELD) //字段、枚举的常量
@Target(ElementType.METHOD) //方法
@Target(ElementType.PARAMETER) //方法参数
@Target(ElementType.CONSTRUCTOR) //构造函数
@Target(ElementType.LOCAL_VARIABLE)//局部变量
@Target(ElementType.ANNOTATION_TYPE)//注解
@Target(ElementType.PACKAGE) ///包
@Document：说明该注解将被包含在javadoc中
@Inherited：说明子类能够继承父类中的该注解
案例：
@Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD, ElementType.LOCAL_VARIABLE})
@Retention(RetentionPolicy.SOURCE)
public @interface Xml {
String[] layouts();
}
@Xml(layouts = "activity_main")
------------------------回家须要再调试看看---------------------------------
2.Activity之间的通讯
Intent/Bundle
3.Activity向Fragment传递数据
1).Bundle之间通讯
fragment.setArguments------>Activity与Fragment之间的通讯桥梁
getArguments()---->得到Bundle对象，仍是key-value的模式
2).直接在Activity之间定义
在onAttach绑定时候，强制转换Acitivity的对象得到真实对象
4.Fragment向Activity对象传递数据
调用流程：
5.Activity与Service之间通讯
1).绑定服务，利用ServiceConnection之间的通讯
Activity写的代码:
Service写的代码:
2).利用Intent之间的通讯
3).定义一个callback接口来监听服务中进程的变化
Service定义接口
Activity进行数据的调用
7.service和IntentService的区别
onHandleIntent在IntentService是抽象类，须要继承去实现的
相比与Service它使用好处是不用你去手动释放，当你执行完onHandleIntent就会释放service,
其次就是他能够经过执行HandlerThread执行异步操做
8.service的启动和绑定的讲解
service的绑定:
启动服务比绑定服务的优先级高
先绑定服务后启动服务: 绑定服务会转为启动服务运行状态，若是绑定的activity销毁，服务会继续运行
先启动服务后绑定服务: 服务不会转为绑定服务状态，会和Activity绑定，可是activity销毁，会按启动服务生命周期走
startService : 让服务长期运行在后台，可是没法与服务进行通信
bindServcie : 能够与服务进行通信，可是没法长期运行在后台
9.parcelable和serializable区别学习
组件之间存储数据通常用parcelable,serializable将对象写到磁盘中
序列化: 内存中的对象----->磁盘
反序列化: 磁盘中的对象---->内存
parcelable的实现步骤:
1）implements Parcelable
2）重写writeToParcel方法，将你的对象序列化为一个Parcel对象，即：将类的数据写入外部提供的Parcel中，打包须要传递的数据到Parcel容器保存，以便从 Parcel容器获取数据
3）重写describeContents方法，内容接口描述，默认返回0就能够
4）实例化静态内部对象CREATOR实现接口Parcelable.Creator
public class MyParcelable implements Parcelable
{
private int mData;
public int describeContents()
{
return 0;
}
public void writeToParcel(Parcel out, int flags)
{
out.writeInt(mData);
}
public static final Parcelable.Creator<MyParcelable> CREATOR = new Parcelable.Creator<MyParcelable>()
{
public MyParcelable createFromParcel(Parcel in)
{
return new MyParcelable(in);
}
public MyParcelable[] newArray(int size)
{
return new MyParcelable[size];
}
};
private MyParcelable(Parcel in)
{
mData = in.readInt();
}
}
简而言之: 经过writeToParcel将你的对象映射成Parcel对象，再经过createFromParcel将Parcel对象映射成你的对象
10.AIDL的使用
11.WebView面试讲解
1).webview在布局文件中的使用: webview写在其余容器中时(webview彻底销毁的办法,不然会内存泄漏)
2).webviewClient.onPageFinished-------->WebChromeClent.onProgressChanged() ： 页面跳转时候调用这个函数
-
每一个你不满意的现在，都有一个你没有努力的曾经。