準備

　　1、Android 基礎面試　　https://www.jianshu.com/p/ffe7e0561c85?tdsourcetag=s_pcqq_aiomsg（還須要總結知識）

　　　　　　　　　　　　　https://blog.csdn.net/songzi1228/article/details/99975018　　（多線程的總結）

　　　　　　　　　　　　  https://www.jianshu.com/p/90db19b4c98a   （大佬的博客園來觀看使用）

　　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請求協議的講解

1. Accept : 表明接受文本和html格式
   text/html,application/xhtml+xml,application/xml;q=0.9, image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3
2. Accept-Encoding : 支持什麼樣子的編碼
   gzip, deflate, br
3. Accept-Language : 中國語言
   zh-CN,zh;q=0.9
4. Cache-Control : 支持緩存類型
   max-age=0
5. Connection :  長鏈接服務
   keep-alive
6. Cookie :  服務器給客戶端標識的認證
   IMCDNS=1
7. Host :
   www.imooc.com
8. User-Agent :  請求主機的類型
   Mozilla/5.0 ( Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.35 Safari/537.36

　　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()　：　頁面跳轉時候調用這個函數