經典面試題(不斷更新中)

——————————————————————–史上最強面試題————————————————————————————-

AIDL

1、 要使用AIDL的前提的條件我們要只知道它是幹什麼的?
    #AIDL 也就是在Android中定義的一個語言,他是進行進程間通訊的一種實現方式,通過定義AIDL接口,可以實現進程間通訊機制
2、 要知道它的使用步驟,前提條件??
    #需求:比如現在有2個進程需要通信,那麼他們是怎麼進行通訊,使用步驟是什麼??一個A,一個是B,B要用A裏面的服務;
    1)、首先在A中寫一個服務,在服務裏面定義一個方法進行暴露出去 ;
    2)、剛剛我們說了要將這個方法暴露出去那麼怎麼暴露出去,現在就要用到AIDL來實現進程間通訊的機制了 ;
    3)、定義一個接口.把要暴露的方法定義在接口中,不要有public之類的修飾符,不然會報錯!,然後把這個接口的後綴名改爲aidl格式 ;系統會自動在gen生成二個文件其中有一個是以接口名字.java命名的
    4)、在A服務中定義一箇中間人對象,寫一個類繼承Stub(實現接口它的本身已經已經實現了我們AIDL接口語言)實現暴露出去的方法.
    5)、現在B中想要調用A中的服務,那麼就可以通過我們剛剛寫的AIDL來實現2個進程間的通信,把A中的AIDLCody到B的SRC目錄下
    6)、通過BindService綁定到A中的服務,然後在bindService裏面創一個服務連接成功的接口,
    7)、寫一個類實現ServiceConnection,裏面有連接成功和失敗的方法,我們現在就可以在連接成功的時候通過Stub這個對象裏面的asInterface這個方法可以獲取到中間人對象,
    8)、現在有中間人這個對象你就可以對A裏面任意操作了,因爲已經建立起關係了;

Handler

首先要知道Handler是幹什麼用的??
1、要明白Handler,Looper,MesagerQuque,Mesager三者的關係
    1). Mesager 是消息的意思那麼它的消息是通過MesagerQueque來進行維護消息的;
    2). MesagerQuque 是消息隊列的意思,消息最終會進行這個裏面,是以發送的時間順序進行以鏈表的形式進入消息隊列的;
    3). Handler 這個是個重要角色 他是進行處理消息和發送消的關鍵所在,跟Looper建立起聯繫的
    4). Looper 自身具備循環機制,是不斷重消息隊列裏面取消息的;
2、明白當在子線程發送消息的是怎麼在主線程中收到消息的
    1)當我們在主線程創建一個Handler對象會進入Handler的構造方法,構造方法裏面有一個Looper.myLooper對象,當我們點擊進去發現有一個當前線程get方法,那麼有get就有set,set方法裏面創建一個了一個Looper對象,looper對象裏面會創建一個消息隊列,現在有了消息對列,那消息是怎麼進入到我這個消息隊列裏面的??又是怎麼出去的???
    2). 消息入隊,enqueueMessage就是消息隊列的裏面的方法,它就是進行入隊的,那麼是怎麼入隊了,因爲當我們不管是通過Handler.XXX發送消息最終都會都到sendMesagerAtTime方法,然後消息對象是以時間進行排序進入消息對列裏面,現在我們知道消息怎麼進入隊列,哪消息怎麼出去了??
    3). 消息出隊,是在Looper.loop裏面Looper對象.消息隊列,通過next取出消息,一直是死循環取消息,這裏有可能會造成線程阻塞,爲什麼會造成阻塞(有可能又在主線程中做耗時的操作了),現在知道消息的入隊和出隊了  那麼怎麼消息就跑到主線程了
    4). 剛剛在Looper.loop()裏面取完消息的時候就會mes.tager.dispatchMessage(msg);把消息分發出去.tager就代表發送消息的handler;
    5). 剛剛在Looper裏面分發完消息,現在就回到Handler.dispatchMessage(),通過看先消息自身的回調如果不等於null的話,就調用自身的run方法,否則調用Callback中的handleMessage,如果前面都不滿足的話  ,最後才調用Handler自身的HandlerMeaaseger方法更新UI

自定義控件

1、明白繼承View的流程
    1). 自定義View的屬性
    2). 在View的構造方法中獲取我們自定義的屬性
    3). 重寫onMesure
    4). 重寫onDraw

Android中的設計模式

1. 明白單列的好處???
    1). 避免創建多個對象,佔用內存空間
  明白創建單列模式有哪些方式???
    1). 我喜歡用內部類的形式
        好處: 節省內存,線程安全
    2). 雙重鎖懶漢式  安全  但是效率不好
    單例模式

定義

保證一個類僅有一個實例，並提供一個訪問它的全局訪問點。
Singleton:負責創建Singleton類自己的唯一實例，並提供一個getInstance的方法，讓外部來訪問這個類的唯一實例。
餓漢式：  private static Singleton uniqueInstance = new Singleton(); 
懶漢式  private static Singleton uniqueInstance = null; 
功能

單例模式是用來保證這個類在運行期間只會被創建一個類實例，另外，單例模式還提供了一個全局唯一訪問這個類實例的訪問點，就是getInstance方法。

範圍

Java裏面實現的單例是一個虛擬機的範圍。因爲裝載類的功能是虛擬機的，所以一個虛擬機在通過自己的ClassLoader裝載餓漢式實現單例類的時候就會創建一個類的實例。

懶漢式單例有延遲加載和緩存的思想

優缺點

懶漢式是典型的時間換空間
餓漢式是典型的空間換時間
不加同步的懶漢式是線程不安全的。比如，有兩個線程，一個是線程A，一個是線程B，它們同時調用getInstance方法，就可能導致併發問題。

餓漢式是線程安全的，因爲虛擬機保證只會裝載一次，在裝載類的時候是不會發生併發的。

如何實現懶漢式的線程安全？

加上synchronized即可

public static synchronized Singleton getInstance(){}
但這樣會降低整個訪問的速度，而且每次都要判斷。可以用雙重檢查加鎖。

雙重加鎖機制，指的是：並不是每次進入getInstance方法都需要同步，而是先不同步，進入方法過後，先檢查實例是否存在，如果不存在才進入下面的同步塊，這是第一重檢查。進入同步塊後，再次檢查實例是否存在，如果不存在，就在同步的情況下創建一個實例。這是第二重檢查。

雙重加鎖機制的實現會使用一個關鍵字volatile，它的意思是：被volatile修飾的變量的值，將不會被本地線程緩存，所有對該變量的讀寫都是直接操作共享內存，從而確保多個線程能正確的處理該變量。


/**
 * 雙重檢查加鎖的單例模式
 * @author dream
 *
 */
public class Singleton {

/**
 * 對保存實例的變量添加volitile的修飾
 */
private volatile static Singleton instance = null;
private Singleton(){

}

public static Singleton getInstance(){
    //先檢查實例是否存在，如果不存在才進入下面的同步塊
    if(instance == null){
        //同步塊，線程安全的創建實例
        synchronized (Singleton.class) {
            //再次檢查實例是否存在，如果不存在才真正的創建實例
            instance = new Singleton();
        }
    }
    return instance;
}

}

一種更好的單例實現方式

public class Singleton {

/**
 * 類級的內部類，也就是靜態類的成員式內部類，該內部類的實例與外部類的實例
 * 沒有綁定關係，而且只有被調用時纔會裝載，從而實現了延遲加載
 * @author dream
 *
 */
private static class SingletonHolder{
    /**
     * 靜態初始化器，由JVM來保證線程安全
     */
    private static final Singleton instance = new Singleton();
}

/**
 * 私有化構造方法
 */
private Singleton(){

}

public static Singleton getInstance(){
    return SingletonHolder.instance;
}

}

根據《高效Java第二版》中的說法，單元素的枚舉類型已經成爲實現Singleton的最佳方法。

package example6;

/**
 * 使用枚舉來實現單例模式的示例
 * @author dream
 *
 */
public class Singleton {

/**
 * 定義一個枚舉的元素，它就代表了Singleton的一個實例
 */
uniqueInstance;

/**
 * 示意方法，單例可以有自己的操作
 */
public void singletonOperation(){
    //功能樹立
}
}

本質

控制實例數量

何時選用單例模式

當需要控制一個類的實例只能有一個，而且客戶只能從一個全局訪問點訪問它時，可以選用單例模式，這些功能恰好是單例模式要解決的問題。
2. 適配器模式:ListView,GridView的Adapter
    1). 簡介: 不同的數據提供使用一個適配器來想一個相同的客服提供服務
3. 建造者模式:AlertDialog.Builder
    1). 簡介: 可以分步地構造每一部分.
4. 享元模式:Message.obtainMessage通過Message對象來避免大量的Message對象被頻繁的創建和銷燬
    1). 運用共享技術有效的支持大量細粒度的對象
5. 命令模式: Handler.post後Handler.handlerMessage
    1). 簡介: 把請求封裝成一二對象發送出去,方便定製、排隊、取消.
6. 迭代器模式: 如通過Hashtable.elements方法可以得到一個Enumeration，然後通過這個Enumeration訪問Hashtable中的數據，而不用關心Hashtable中的數據存放方式
    1). 提供一個方法順序訪問數據集合中的所有數據而又不暴露對象的內部表示
7. 備忘錄模式：Activity的onSaveInstanceState和onRestoreInstanceState就是通過Bundle這種序列化的數據結構來存儲Activity的狀態，至於其中存儲的數據結構，這兩個方法不用關心
    1). 簡介: 不需要了解對象的內部結構的情況下備份對象的狀態，方便以後恢復
8. 觀察者模式: 我們可以通過BaseAdapter.registerDataSetObserver和BaseAdapter.unregisterDataSetObserver兩方法來向BaseAdater註冊、註銷一個DataSetObserver。這個過程中，DataSetObserver就是一個觀察者，它一旦發現BaseAdapter內部數據有變量，就會通過回調方法DataSetObserver.onChanged和DataSetObserver.onInvalidated來通知DataSetObserver的實現類。事件通知也是觀察者模式
    1). 簡介：一個對象發生改變時，所有信賴於它的對象自動做相應改變。
9. 原型模式：比如我們需要一張Bitmap的幾種不同格式：ARGB_8888、RGB_565、ARGB_4444、ALAPHA_8等。那我們就可以先創建一個ARGB_8888的Bitmap作爲原型，在它的基礎上，通過調用Bitmap.copy(Config)來創建出其它幾種格式的Bitmap。另外一個例子就是Java中所有對象都有的一個名字叫clone的方法，已經原型模式的代名詞了
    1). 簡介：在系統中要創建大量的對象，這些對象之間具有幾乎完全相同的功能，只是在細節上有一點兒差別。
10. 狀態模式：View.onVisibilityChanged方法，就是提供了一個狀態模式的實現，允許在View的visibility發生改變時，引發執行onVisibilityChanged方法中的動作。
    1). 簡介：狀態發生改變時，行爲改變。
11. 策略模式：
    舉例：Java.util.List就是定義了一個增（add）、刪（remove）、改（set）、查（indexOf）策略，至於實現這個策略的ArrayList、LinkedList等類，只是在具體實現時採用了不同的算法。但因爲它們策略一樣，不考慮速度的情況下，使用時完全可以互相替換使用。
    1). 簡介: 定義了一系封裝了算法、行爲的對象,他們可以相互替換.
12. 調解者模式
    簡介：一個對象的某個操作需要調用N個對象的M個方法來完成時，把這些調用過程封裝起來，就成了一個調解者
    舉例：如Resource.getDrawable方法的實現邏輯是這樣的：創建一個緩存來存放所有已經加載過的，如果getDrawable中傳入的id所對應的Drawable以前沒有被加載過，那麼它就會根據id所對應的資源類型，分別調用XML解析器生成，或者通過讀取包中的圖片資源文件來創建Drawable。而Resource.getDrawable把涉及到多個對象、多個邏輯的操作封裝成一個方法，就實現了一個調解者的角色。
12. 抽象工程模式
    DAO與Service的使用

大圖片造成的OOM是怎麼解決的

1、通過壓縮的方式,具體怎麼壓縮??
    直接使用ImageView顯示bitmap會佔用較多資源，特別是圖片較大的時候，可能導致崩潰。 
    使用BitmapFactory.Options設置inSampleSize, 這樣做可以減少對系統資源的要求。 
    屬性值inSampleSize表示縮略圖大小爲原始圖片大小的幾分之一，即如果這個值爲2，則取出的縮略圖的寬和高都是原始圖片的1/2，圖片大小就爲原始大小的1/4。 

    BitmapFactory.Options bitmapFactoryOptions = new BitmapFactory.Options();  
    bitmapFactoryOptions.inJustDecodeBounds = true;  
    bitmapFactoryOptions.inSampleSize = 2;  
    // 這裏一定要將其設置回false，因爲之前我們將其設置成了true    
    // 設置inJustDecodeBounds爲true後，decodeFile並不分配空間，即，BitmapFactory解碼出來的Bitmap爲Null,但可計算出原始圖片的長度和寬度    
    options.inJustDecodeBounds = false;  
    Bitmap bmp = BitmapFactory.decodeFile(sourceBitmap, options);  

2、通過LRU緩存的方式,具體怎麼實現的??
    指定內存空間,我們自己分分配緩存大小

項目中MVC用到的多嗎??都代表什麼意思??

目前項目中用的基本上都是MVC 因爲MVC模式它是將視圖和數據,邏輯代碼都剝離了出來,這樣做的效果就是便於以後添加功能比較方便,便於維護
M:Model   負責處理數據  比如javaBean,聯網處理,
V:View    處理界面展示結果的 XML
C:Controller  控制器  就是起橋樑作用,負責Model,View層數據之間的通信
好處: 便於後期維護和添加新功能
缺點: 它的首要職責是加載應用的佈局和初始化用戶的界面,並接受來自用戶的操作請求,進而做響應.Activty類的職責不斷增加,以致變得龐大臃腫.

大概說一下MVP???

M: model提供數據
V: 負責顯示
P: 負責邏輯處理

MVC與MVP之前的區別???

View與Model並不直接交互,而是通過與Presenter交互來與Model直接交互
通常View與Presenter是一對一的,但複雜的View可能綁定多個Presenter來處理邏輯,而Controller是基於行爲的,並且可以被多個View共享,Controller可以負責決定顯示那個View

將一講你在項目中線程池用的多嗎???

將一講你在項目中對象池用的多嗎(聽都聽不懂)???

ArrayList(集合裏面有1~100的數,怎麼用2種方法可以使偶數去重)

怎麼讀取N個大文件效率怎麼最高(思路:創建多個線程);

反射(你在項目中用的多嗎,具體談談)

1). fromName(全類名);(讀取配置文件)
2). 類名.Class();(當做靜態方法的鎖對象)
3). 對象名.getClass();(判斷是不是同一個字節碼對象)

Android屬性動畫怎麼獲取變化中的ARGB值(利用ValuesAnimontor)

通過屬性動畫中的值動畫添加一個監聽器通過監聽器中的對象名獲取變化中的值

事件傳遞機制(將一講事件處理,如果都不要事件,最後事件都被誰消費了)

ListView Item上面有一個Button,當我點擊ListView的時候,Button把事件搶走了,這怎麼處理啊?

購物車中增加物品數量邏輯怎麼實現

getMeasuredWidth與getWidth區別

1). getMeasuredWidth方法獲得的值是setMeasuredDimension方法設置的值，它的值在measure方法運行後就會確定
2). getWidth方法獲得是layout方法中傳遞的四個參數中的mRight-mLeft，它的值是在layout方法運行後確定的
3). 一般情況下在onLayout方法中使用getMeasuredWidth方法，而在除onLayout方法之外的地方用getWidth方法。

Service中的onStartCommand和onStart()方法有什麼區別???

1). 在Android API 2.0 之後 實現onStart等於實現了onStartCommand()方法;
2). 在AndroidAPI  2.0之後onStart()被onStartCommand()方法取代了;
3). 無論何時， 都會先調用onStartCommand()，在調用onStart()。    
注意:onStartCommand()方法必須返回一個整數，這個整數是一個描述了在系統的殺死事件中，系統應該如何繼續這個服務的值（雖然你能夠修改這個值，但是IntentService處理還是爲你提供了默認實現）。從onStartCommand()方法中返回的值必須是以下常量：    
1. START_NOT_STICKY
如果系統在onStartCommand()方法返回之後殺死這個服務，那麼直到接受到新的Intent對象，這個服務纔會被重新創建。這是最安全的選項，用來避免在不需要的時候運行你的服務。
2. START_STICKY
如果系統在onStartCommand()返回後殺死了這個服務，系統就會重新創建這個服務並且調用onStartCommand()方法，但是它不會重新傳遞最後的Intent對象，系統會用一個null的Intent對象來調用onStartCommand()方法，在這個情況下，除非有一些被髮送的Intent對象在等待啓動服務。這適用於不執行命令的媒體播放器（或類似的服務），它只是無限期的運行着並等待工作的到來。
3. START_REDELIVER_INTENT
如果系統在onStartCommand()方法返回後，系統就會重新創建了這個服務，並且用發送給這個服務的最後的Intent對象調用了onStartCommand()方法。任意等待中的Intent對象會依次被髮送。這適用於那些應該立即恢復正在執行的工作的服務，如下載文件。

Http協議

協議就是字段和格式描述的文檔
1). 字段
    幫助辨識數據的含義
2). 格式 : 幫助將數據歸類
    JSON : 數據格式簡單,數據精簡,節約數據流量
    XML  : 格式良好,複雜,耗費流量但是擴展性好

TCP/IP協議

IP: 就是每臺電腦上的IP地址,端口用於查找電腦運行的應用;
TCP:用於傳輸數據的
    TCP:面向連接,三次握手,是穩定的傳輸協議
    UDP:面向無連接,數據不安全,傳輸的數據有可能丟失

事件分發機制

1). 點擊屏幕的時候觸發Activity的onTouch()事件,當Activity接收到觸摸事件的時候,將遍歷子View進行Down事件分發ViewGroup可以看做是遞歸的,分發事件的目的就是要看是哪個子View需要Down事件,如果需要就在子View的onTouchEvent()方法中放回true,事件將有它消費,不在進行分發;
2). 當ViewGroup中所有子View都不需要Down事件的話,最終事件會調用父類View的dispatchTouchEvent(),在所有子View都不處理的情況下,會調用Activity本身的onTouch()方法;

2016/9/29

onClick()怎麼處理??

1). btn1.setOnClickListener(new OnClickListener())
2). Xml佈局中定義"onClick"
3). 讓當前類實現onClickListener();
4). btn_call.setOnClickListener(new MyOnClickListener());

OOM與泄露區別??leakcanary

1.內存溢出 out of memory
是指程序在申請內存時，沒有足夠的內存空間供其使用，出現out of memory；比如申請了一個integer,但給它存了long才能存下的數，那就是內存溢出。
2.內存泄露 memory leak
是指程序在申請內存後，無法釋放已申請的內存空間，一次內存泄露危害可以忽略，但內存泄露堆積後果很嚴重，無論多少內存,遲早會被佔光。
3.二者的聯繫
內存泄露最終會導致內存溢出    

內存溢出(00M)
    內存溢出是指當對象的內存佔用已經超出內存的控件大小,這時未經處理的異常就會拋出
    .比如常見的內存溢出情況有: Bitmap過來;引用沒有釋放;資源對象沒有關閉
    簡單而言,內存溢出就是要求分配的內存超出了系統能給的,系統不能滿足需求,於是產生溢出
1). 長期保持某些資源Context的引用,垃圾回收器就無法回收它
2). Android中常見就是Activity被應用在調用finish之後卻沒有釋放,第二次打開activity又重新創建
3). Android的每個應用程序都會使用一個專有的虛擬機來運行,他是由Zygote服務進程孵化出來的,也就是說每個應用程序都是在屬於自己的進程中運行的.
4). 佔用內存較多的對象
    保存了多個耗用內存過大的對象或加載單個超大的圖片,造成內存超出限制.

內存泄露(memory Leak)----memory leak 會最終導致oom(可以用heap來觀察)
    有些對象只有有限的生命週期.當他們的任務完成之後,他們將被垃圾回收,如果對象還被一系列的引用,他就會導致內存泄露.隨着泄露的累積,app將消耗完內存.
1). 資源對象沒有關閉(File,Cursor,SqLite)
2). 使用Adapter時,沒有使用緩存
3). 沒有即時調用recycle()釋放不在使用bitmap
4). 使用application的context替代activity的context
5). 廣播註冊沒有取消
6). handler應該聲明爲靜態對象,並在其內部類中保存一個對外部類的弱引用;

說說三級緩存具體怎麼實現???

1). 內存(我們自己指定緩存的大小和有效時間)
2). 本地(SD卡或者getDirChche())
3). 網絡(請求網絡獲取數據)

內存優化???

    單列
    listView 複用
    Bitmap壓縮
    三級緩存
內存檢測 
    heap
    adb
    ddms
    Memory Analyzer(MAT)

自我介紹???

開啓廣播的方式,區別??

清單文件中註冊(生命週期是最長的)
代碼中註冊(隨着Activity銷燬而銷燬)
有序廣播  可以終止廣播
無序廣播  在規定的時候段定時播放

之前薪資和現在薪資,爲什麼要那麼多???

根據目前北京的市場,畢竟是3年的工作經驗

現在住在那 , 做多少路車過來???

   海淀,出門提前把路線規劃好

回去瞭解下直播???

即時通訊

1. 申請主應用的APP證明.
2. 註冊成功之後,登錄後臺:填寫應用包名,應用名等相關信息
3. 點擊確認,進行申請.
    這樣appauth就申請成功了,點擊後面的複製.粘貼到項目中的Androidmanifest文件中即可
4. 配權限
5. 導入SDK

你該怎麼提升自己

看博客,,逛GitHub,自己寫總結

Android中內存優化

答：android 內存泄露容易導致內存溢出，又稱爲 OOM。
Android 內存優化策略：
1）在循環內儘量不要使用局部變量
2）不用的對象即時釋放，即指向 NULL
3）數據庫的 cursor 即時關閉。
4）構造 adapter 時使用緩存 contentview
5）調用 registerReceiver()後在對應的生命週期方法中調用 unregisterReceiver()
6）即時關閉 InputStream/OutputStream。
7） android 系統給圖片分配的內存只有 8M, 圖片儘量使用軟引用, 較大圖片可通過 BitmapFactory縮放後再使用,並及時 recycle
8）儘量避免 static 成員變量引用資源耗費過多的實例。

說說對象池???

對象池使用的基本思路是：將用過的對象保存起來，等下一次需要這種對象的時候，再拿出來重複使用，從而在一定程度上減少頻繁創建對象所造成的開銷。 並非所有對象都適合拿來池化――因爲維護對象池也要造成一定開銷。對生成時開銷不大的對象進行池化，反而可能會出現“維護對象池的開銷”大於“生成新對象的開銷”，從而使性能降低的情況。但是對於生成時開銷可觀的對象，池化技術就是提高性能的有效策略了

線程池???

線程池的基本思想還是一種對象池的思想，開闢一塊內存空間，裏面存放了衆多(未死亡)的線程，池中線程執行調度由池管理器來處理。當有線程任務時，從池中取一個，執行完成後線程對象歸池，這樣可以避免反覆創建線程對象所帶來的性能開銷，節省了系統的資源。
比如：一個應用要和網絡打交道，有很多步驟需要訪問網絡，爲了不阻塞主線程，每個步驟都創建個線程，在線程中和網絡交互，用線程池就變的簡單，線程池是對線程的一種封裝，讓線程用起來更加簡便，只需要創一個線程池，把這些步驟像任務一樣放進線程池，在程序銷燬時只要調用線程池的銷燬函數即可。
java提供了ExecutorService和Executors類，我們可以應用它去建立線程池。

如何不讓外界應用接收到你的廣播？？？

LocalBroadcastManager是Android Support包提供了一個工具，是用來在同一個應用內的不同組件間發送Broadcast的。
使用LocalBroadcastManager有如下好處：
發送的廣播只會在自己App內傳播，不會泄露給其他App，確保隱私數據不會泄露
其他App也無法向你的App發送該廣播，不用擔心其他App會來搞破壞
比系統全局廣播更加高效。

Android中的Parcelable？？？

1). 實現Parcelable就是爲來進行序列化,那麼,爲什麼要序列化??
    一. 永久性保存對象,保存對象的字節序列到本地文件中;
    二. 通過序列化對象在網絡中傳遞對象;
    三. 通過序列化在進程間傳遞對象;
2). 實現序列化的方法
    Android中實現序列化有2個選擇: 一是實現Serializable接口(是Java本身就支持的),二是實現Parcelable接口()
    是Android特有的功能,效率比實現Serializable接口高效,可用於Intent數據傳遞,也可以用於進程間通訊(IPC)Serializable接口非常簡單,聲明一下就可以了,而實現Parcelable接口稍微複雜一些,但效率更高,推薦用這種性能
注: Android中Intent傳遞對象有兩種方法：一是Bundle.putSerializable(Key，Object)，另一種是Bundle.putParcelable(Key，Object)。當然這些Object是有一定的條件的，前者是實現了Serializable接口，而後者是實現了Parcelable接口。
3). 選擇序列化方法的原則
    一. 在使用內存的時候，Parcelable比Serializable性能高，所以推薦使用Parcelable;
    二. Serializable在序列化的時候會產生大量的臨時變量，從而引起頻繁的GC;
    三. Parcelable不能使用在要將數據存儲在磁盤上的情況，因爲Parcelable不能很好的保證數據的持續性在外界有變化的情況下。儘管Serializable效率低點，但此時還是建議使用Serializable ;
4). 應用場景
    需要在多個部件(Activity或Service)之間通過Intent傳遞一些數據，簡單類型（如：數字、字符串）的可以直接放入Intent。複雜類型必須實現Parcelable接口;
5). Parcelable接口定義

public interface Parcelable

{
//內容描述接口，基本不用管
public int describeContents();
//寫入接口函數，打包
public void writeToParcel(Parcel dest, int flags);
//讀取接口，目的是要從Parcel中構造一個實現了Parcelable的類的實例處理。因爲實現類在這裏還是不可知的，所以需要用到模板的方式，繼承類名通過模板參數傳入
//爲了能夠實現模板參數的傳入，這裏定義Creator嵌入接口,內含兩個接口函數分別返回單個和多個繼承類實例
public interface Creator
{
public T createFromParcel(Parcel source);
public T[] newArray(int size);
}
}

6). 實現Parcelable步驟
    1）. implements Parcelable
    2）. 重寫writeToParcel方法，將你的對象序列化爲一個Parcel對象，即：將類的數據寫入外部提供的Parcel中，打包需要傳遞的數據到Parcel容器保存，以便從 Parcel容器獲取數據
    3）. 重寫describeContents方法，內容接口描述，默認返回0就可以
    4）. 實例化靜態內部對象CREATOR實現接口Parcelable.Creator
    `public static final Parcelable.Creator<T> CREATOR`
    `注`：其中public static final一個都不能少，內部對象CREATOR的名稱也不能改變，必須全部大寫。需重寫本接口中的兩個方法：createFromParcel(Parcel in) 實現從Parcel容器中讀取傳遞數據值，封裝成Parcelable對象返回邏輯層，newArray(int size) 創建一個類型爲T，長度爲size的數組，僅一句話即可（return new T[size]），供外部類反序列化本類數組使用。
    `簡而言之`：通過writeToParcel將你的對象映射成Parcel對象，再通過createFromParcel將Parcel對象映射成你的對象。也可以將Parcel看成是一個流，通過writeToParcel把對象寫到流裏面，在通過createFromParcel從流裏讀取對象，只不過這個過程需要你來實現，因此寫的順序和讀的順序必須一致。
    代碼如下:
`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();
 }

}`
8). Serializable實現與Parcelabel實現的區別
1). Serializable的實現，只需要implements Serializable 即可。這只是給對象打了一個標記，系統會自動將其序列化
2). Parcelabel的實現，不僅需要implements Parcelabel，還需要在類中添加一個靜態成員變量CREATOR，這個變量需要實現 Parcelable.Creator 接口

如何高效的關閉打開多個activity的應用

sp的提交方式

關於RecyclerView的特點，與listview相比的優點，點擊事件的實現。

關於線程池

AsynTask的內部實現線程池及Handler的維護

關於OOM的認識

自定義控件的流程

觀察者模式

——————————————————————-JAVA中多線程難點—————————————————————————-

####Java中多線程同步是什麼???

 在多線程程序下，同步能控制對共享資源的訪問。如果沒有同步，當一個 Java 線程在修改一個共享變量時，另外一個線程正在使用或者更新同一個變量，這樣容易導致程序出現錯誤的結果。

解釋實現多線程的幾種方法?

1). Java 線程可以實現 Runnable 接口或者繼承 Thread 類來實現，當你打算多重繼承時，優先選擇實現 Runnable

Thread.start ()與 Thread.run ()有什麼區別？

1). Thread.start ()方法(native)啓動線程，使之進入就緒狀態，當 cpu 分配時間該線程時，由 JVM 調度執行 run ()方法。

爲什麼需要 run ()和 start ()方法，我們可以只用 run ()方法來完成任務嗎

1). 我們需要 run ()&start ()這兩個方法是因爲 JVM 創建一個單獨的線程不同於普通方法的調用，所以這項工作由線程的 start 方法來完成，start 由本地方法實現，需要顯示地被調用，使用這倆個方法的另外一個好處是任何一個對象都可以作爲線程運行，只要實現了 Runnable 接口，這就避免因繼承了 Thread 類而造成的 Java 的多繼承問題

什麼是 ThreadLocal 類，怎麼使用它

ThreadLocal 是一個線程級別的局部變量，並非“本地線程”。ThreadLocal 爲每個使用該變量的線程提供了一個獨立的變量副本，每個線程修改副本時不影響其它線程對象的副本(譯者注).

下面是線程局部變量(ThreadLocal variables)的關鍵點：
一個線程局部變量(ThreadLocal variables)爲每個線程方便地提供了一個單獨的變量。
ThreadLocal 實例通常作爲靜態的私有的(private static)字段出現在一個類中，這個類用來關聯一個線程。
當多個線程訪問 ThreadLocal 實例時，每個線程維護 ThreadLocal 提供的獨立的變量副本。
常用的使用可在 DAO 模式中見到，當 DAO 類作爲一個單例類時，數據庫鏈接(connection)被每一個線程獨立的維護，互不影響。(基於線程的單例)

什麼時候拋出 InvalidMonitorStateException 異常，爲什麼？

調用 wait ()/notify ()/notifyAll ()中的任何一個方法時，如果當前線程沒有獲得該對象的鎖，那麼就會拋出 IllegalMonitorStateException 的異常(也就是說程序在沒有執行對象的任何同步塊或者同步方法時，仍然嘗試調用 wait ()/notify ()/notifyAll ()時)。由於該異常是 RuntimeExcpetion 的子類，所以該異常不一定要捕獲(儘管你可以捕獲只要你願意).作爲 RuntimeException，此類異常不會在 wait (),notify (),notifyAll ()的方法簽名提及

Sleep ()、suspend ()和 wait ()之間有什麼區別

Thread.sleep ()使當前線程在指定的時間處於“非運行”（Not Runnable）狀態。線程一直持有對象的監視器。比如一個線程當前在一個同步塊或同步方法中，其它線程不能進入該塊或方法中。如果另一線程調用了 interrupt ()方法，它將喚醒那個“睡眠的”線程。

注意：sleep ()是一個靜態方法。這意味着只對當前線程有效，一個常見的錯誤是調用t.sleep ()，（這裏的t是一個不同於當前線程的線程）。即便是執行t.sleep ()，也是當前線程進入睡眠，而不是t線程。t.suspend ()是過時的方法，使用 suspend ()導致線程進入停滯狀態，該線程會一直持有對象的監視器，suspend ()容易引起死鎖問題。

object.wait ()使當前線程出於“不可運行”狀態，和 sleep ()不同的是 wait 是 object 的方法而不是 thread。調用 object.wait ()時，線程先要獲取這個對象的對象鎖，當前線程必須在鎖對象保持同步，把當前線程添加到等待隊列中，隨後另一線程可以同步同一個對象鎖來調用 object.notify ()，這樣將喚醒原來等待中的線程，然後釋放該鎖。基本上 wait ()/notify ()與 sleep ()/interrupt ()類似，只是前者需要獲取對象鎖

在靜態方法上使用同步時會發生什麼事

同步靜態方法時會獲取該類的“Class”對象，所以當一個線程進入同步的靜態方法中時，線程監視器獲取類本身的對象鎖，其它線程不能進入這個類的任何靜態同步方法。它不像實例方法，因爲多個線程可以同時訪問不同實例同步實例方法

當一個同步方法已經執行，線程能夠調用對象上的非同步實例方法嗎?

可以，一個非同步方法總是可以被調用而不會有任何問題。實際上，Java 沒有爲非同步方法做任何檢查，鎖對象僅僅在同步方法或者同步代碼塊中檢查。如果一個方法沒有聲明爲同步，即使你在使用共享數據 Java 照樣會調用，而不會做檢查是否安全，所以在這種情況下要特別小心。一個方法是否聲明爲同步取決於臨界區訪問(critial section access)，如果方法不訪問臨界區(共享資源或者數據結構)就沒必要聲明爲同步的。

下面有一個示例說明：Common 類有兩個方法 synchronizedMethod1()和 method1()，MyThread 類在獨立的線程中調用這兩個方法

在一個對象上兩個線程可以調用兩個不同的同步實例方法嗎

不能，因爲一個對象已經同步了實例方法，線程獲取了對象的對象鎖。所以只有執行完該方法釋放對象鎖後才能執行其它同步方法。

什麼是死鎖

死鎖就是兩個或兩個以上的線程被無限的阻塞，線程之間相互等待所需資源。這種情況可能發生在當兩個線程嘗試獲取其它資源的鎖，而每個線程又陷入無限等待其它資源鎖的釋放，除非一個用戶進程被終止。就 JavaAPI 而言，線程死鎖可能發生在一下情況。

當兩個線程相互調用 Thread.join ()
當兩個線程使用嵌套的同步塊，一個線程佔用了另外一個線程必需的鎖，互相等待時被阻塞就有可能出現死鎖。

什麼是線程餓死，什麼是活鎖

線程餓死和活鎖雖然不想是死鎖一樣的常見問題，但是對於併發編程的設計者來說就像一次邂逅一樣。

當所有線程阻塞，或者由於需要的資源無效而不能處理，不存在非阻塞線程使資源可用。JavaAPI 中線程活鎖可能發生在以下情形：

當所有線程在程序中執行 Object.wait (0)，參數爲 0 的 wait 方法。程序將發生活鎖直到在相應的對象上有線程調用 Object.notify ()或者 Object.notifyAll ()。
當所有線程卡在無限循環中

————————————————————–JAVA基礎經典面試題————————————————————————–

九種基本數據類型的大小，以及他們的封裝類。

boolean  (8位但是隻能爲true false)  Boolean  
byte      8       Byte  
char      16       Character  
short     16        Short  
int       32       Integer  
long      64       Long  
float     32       Float  
double    64       Double  
void                Void

Switch能否用string做參數？

java7 以前不行是用轉換爲枚舉實現，現在直接可以

equals與==的區別。

equals檢查內容是否一致  
==檢查內存存儲的地址是否一致

Object有哪些公用方法？

hashCode();wait();notify();equals();getClass();toString();  clone();finalize();

Java的四種引用，強弱軟虛，用到的場景。

強引用：我們一般用的都是強引用，不會被回收  
軟引用：內存敏感的高速緩存，當jvm 報out of memery時回收  
弱引用：gc時必須被回收  
虛引用：gc時緊收到消息，不能做任何操作

Hashcode的作用。

用於比較兩個對象是否相同，比如set的相同就是用hashcode

ArrayList、LinkedList、Vector的區別。

都是數組實現list接口，
vector是連續線程安全，  
ArrayList是連續內存，查找方便，
LinkedList是鏈表結構，增刪方便

String、StringBuffer與StringBuilder的區別。

String是字符串常量，不可改變，其餘的是字符串變量，主要用於字符串的修改，
buffer線程安全，
builder非線程安全

Map、Set、List、Queue、Stack的特點與用法。

鍵值對：hashmap，hashtable，weakhashmap，sortedmap  
不重複集合：sortedset，hashset  
有序數列：linkedList，arraylist，vector  
隊列：先進先出  棧：先進後出

HashMap和HashTable的區別。

hashtable線程安全，不接受鍵值對爲nul

HashMap和ConcurrentHashMap的區別，HashMap的底層源碼。

ConcurrentHashMap通過分段實現線程安全

TreeMap、HashMap、LindedHashMap的區別。

Collection包結構，與Collections的區別。

Collections，是一個工具類，比如：Collections.sort（list）

try catch finally，try裏有return，finally還執行麼？

return後還執行，但是無法修改已經返回的內容

Excption與Error包結構。OOM你遇到過哪些情況，SOF你遇到過哪些情況。

Java面向對象的三個特徵與含義。

封裝：方法與屬性封裝  
繼承：節省代碼，擴展  
多態：父類引用指向不同的實例，重寫，重載

Override和Overload的含義去區別。

重寫：子類中有一個父類中名字參數一樣的函數，異常變少，訪問權限變大  
重載：同類當中參數列表不一致

Interface與abstract類的區別。

一個是類，一個是接口  
接口內部變量必須public static final  可以有實現的方法，接口全部沒實現  訪問權限：接口只有public和protected  多繼承、構造方法

Static class 與non static class的區別。

java多態的實現原理。

父類引用指向不同的實例，重寫，重載

實現多線程的兩種方法：Thread與Runable。

Thread與Runable。  
繼承類，實現接口

線程同步的方法：sychronized、lock、reentrantLock等。

sychronized：修飾的方法，塊一次只有一個線程可以訪問，其他的阻塞  
lock：一個接口，用於try的finally中可以主動的釋放鎖，trylock方法可以指定等待時間，靈活  
reentrantLock：lock的實現類

鎖的等級：方法鎖、對象鎖、類鎖。

對象鎖：對象的方法，代碼塊上鎖了，獲取對象鎖才能訪問  
方法鎖：方法上鎖  
類鎖：static方法上鎖

寫出生產者消費者模式。

生產者（入隊） 緩衝區（隊列管理） 消費者（出隊） 
優點：解耦  併發  閒忙不均

ThreadLocal的設計理念與作用。

多線程多實例的數據傳遞問題，底層有個ThreadlLocalMap來管理

ThreadPool用法與優勢。

newCachedThreadPool創建一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閒線程，若無可回收，則新建線程。  
newFixedThreadPool 創建一個定長線程池，可控制線程最大併發數，超出的線程會在隊列中等待。  
newScheduledThreadPool 創建一個定長線程池，支持定時及週期性任務執行。  
newSingleThreadExecutor 創建一個單線程化的線程池，它只會用唯一的工作線程來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先級)執行。

Concurrent包裏的其他東西：ArrayBlockingQueue、CountDownLatch等等。

wait()和sleep()的區別。

sleep沒有放棄對象鎖，wait放棄了，thread和object，需要notify喚醒。

foreach與正常for循環效率對比。

簡便了編程與不會越界，但是隻能用於遍歷

Java IO與NIO。

IO                NIO                                              
面向流            面向緩衝
阻塞IO            非阻塞IO
無                選擇器

反射的作用於原理。

泛型常用特點，List能否轉爲List。

靈活變換參數類型，可以

解析XML的幾種方式的原理與特點：DOM、SAX、PULL。

DOM：獲取整個DOM樹，便於節點操作，  
SAX：一邊解析，一邊處理數據，必須自己維護父子關係  
JDOM：比較適合比較小的，不需要實時處理的  
DOM4J：可移植性差

Java與C++對比。

java的完全封裝，類外無函數，萬物皆對象  gc,指針，接口，多繼承的實現

Java1.7與1.8新特性。

java1.7：switch支持String；集合類的支持，安全加減乘除；char的equals操作  
java1.8：Lambda 表達式，接口支持

設計模式：單例、工廠、適配器、責任鏈、觀察者等等。

JNI的使用。

System.LoadLibrary("");//引入庫文件    
public native static void set(int i); //native跨語言調用     
testdll test = new testdll(); //申明方式  
test.set（10）;調用

————————————————————–JVM 經典面試題————————————————————————————-

內存模型以及分區，需要詳細到每個區放什麼。

heap：對象實例  method 
area：常量池，變量信息，方法信息  
stack：方法的調用出入 
program counter：程序偏移量  
native method area：本地方法

堆裏面的分區：

Eden，survival from to，老年代，各自的特點。

對象創建方法，對象的內存分配，對象的訪問定位。

GC的兩種判定方法：

引用計數與引用鏈。  
引用計數爲0；gc root不可達

GC的三種收集方法：標記清除、標記整理、複製算法的原理與特點，分別用在什麼地方，如果讓你優化收集方法，有什麼思路？

先標記後清除，內存碎片  標記整理，先標記後移動內存，開銷大  複製:等分，一塊使用，一塊清理，內存減半

GC收集器有哪些

CMS收集器與G1收集器的特點

Minor GC與Full GC分別在什麼時候發生？

幾種常用的內存調試工具：

jmap、jstack、jconsole。

類加載的五個過程：

加載、驗證、準備、解析、初始化。

雙親委派模型：

Bootstrap ClassLoader、Extension ClassLoader、ApplicationClassLoader。

分派

靜態分派與動態分派

————————————————————–操作系統經典面試題———————————————————————————-

進程和線程的區別

CPU調度的基本單位；程序資源管理分配的單位

死鎖的必要條件，怎麼處理死鎖。

互斥條件（Mutual exclusion）   ：資源不能被共享，只能由一個進程使用。  
請求與保持條件（Hold and wait） ：已經得到資源的進程可以再次申請新的資源。  
非剝奪條件（No pre-emption）    ：已經分配的資源不能從相應的進程中被強制地剝奪。  
循環等待條件（Circular wait）   ： 系統中若干進程組成環路，該環路中每個進程都在等待相鄰進  程正佔用的資源。   合理動態分配，檢查並恢復，打破死鎖條件

Window內存管理方式：段存儲，頁存儲，段頁存儲。

按頁大小分頁分隔虛擬內存，外碎片沒有，內碎片不會大於頁的大小  
按函數或內容分段，可以分開編寫等獨立  
段頁式：先分段再分頁，有點都有開銷變大

進程的幾種狀態。

IPC幾種通信方式。

1.管道中還有命名管道和非命名管道(即匿名管道)之分，非命名管道(即匿名管道)只能用於父子進 程通訊，命名管道可用於非父子進程，命名管道就是FIFO，管道是先進先出的通訊方式 
2.消息隊列是用於兩個進程之間的通訊，首先在一個進程中創建一個消息隊列，然後再往消息隊列 中寫數據，而另一個進程則從那個消息隊列中取數據。需要注意的是，消息隊列是用創建文件的方 式建立的，如果一個進程向某個消息隊列中寫入了數據之後，另一個進程並沒有取出數據，即使向 消息隊列中寫數據的進程已經結束，保存在消息隊列中的數據並沒有消失，也就是說下次再從這個 消息隊列讀數據的時候，就是上次的數據！！！！  
3.信號量，它與WINDOWS下的信號量是一樣的，所以就不用多說了      
4.共享內存，類似於WINDOWS下的DLL中的共享變量，但LINUX下的共享內存區不需要像DLL這樣的東 西，只要首先創建一個共享內存區，其它進程按照一定的步驟就能訪問到這個共享內存區中的數據 ，當然可讀可寫

以上幾種方式的比較：
1.管道：速度慢，容量有限，只有父子進程能通訊
2.FIFO：任何進程間都能通訊，但速度慢
3.消息隊列：容量受到系統限制，且要注意第一次讀的時候，要考慮上一次沒有讀完數據的問題
4.信號量：不能傳遞複雜消息，只能用來同步
5.共享內存區：能夠很容易控制容量，速度快，但要保持同步，比如一個進程在寫的時候，另一個進程要注意讀寫的問題，相當於線程中的線程安全，當然，共享內存區同樣可以用作線程間通訊，不過沒這個必要，線程間本來就已經共享了同一進程內的一塊內存

什麼是虛擬內存

虛擬的一段連續的內存空間，通常是分隔的物理內存碎片

虛擬地址、邏輯地址、線性地址、物理地址的區別。

————————————————————– TCP/IP 經典面試題 ——————————————————————————-

OSI與TCP/IP各層的結構與功能，都有哪些協議

物理層，數據鏈路層，網絡層，運輸層，會話層，表示層，應用層

TCP與UDP的區別。

面向連接，可靠（掉包亂序），快慢，數據量大小的問題

TCP報文結構。

TCP的三次握手與四次揮手過程，各個狀態名稱與含義，TIMEWAIT的作用。

SYN=1，seg=x    SYN=1，ACK=1，ack=x+1，seq=y  ACK=1，seq=x+1，ack=y+1    
FIN ACK:FIN ACK  TIMEWAIT重發最後丟失的ACK包

TCP擁塞控制

“慢啓動”“擁塞避免”“快速重傳 ”“快速恢復”

TCP滑動窗口與回退N針協議

Http的報文結構。

請求行 首部 主體

Http的狀態碼含義。

1.消息，被接受需處理  
2.成功  
3.重定向  
4.請求錯誤  
5.服務器錯誤

Http request的幾種類型。

post改，get查，delete刪，put增  位置url請求行  實體鍵值對  數據量的大小

Http1.1和Http1.0的區別

1.Persistent Connection(持久連接)   在HTTP1.0中，每對Request/Response都使用一個新的連接。   HTTP 1.1則支持Persistent Connection, 並且默認使用persistent connection.  2.HTTP1.1在Request消息頭裏頭多了一個Host域  
3.100 (Continue) Status      100 (Continue) 狀態代碼的使用，允許客戶端在發request消息body之前先用request    header試探一下server，看server要不要接收request body，再決定要不要發request    body。            客戶端在Request頭部中包含   Expect: 100-continue   Server看到之後呢如果回100 (Continue) 這個狀態代碼，客戶端就繼續發request body  
4.新增了些狀態碼  5.HTTP1.1增加了OPTIONS, PUT, DELETE, TRACE, CONNECT這些Request方法

Http怎麼處理長連接

http keep-alive，1.1版本默認長連接

Cookie與Session的作用於原理。

瀏覽器端的cookie和服務端的session會話

電腦上訪問一個網頁，整個過程是怎麼樣的

DNS、HTTP、TCP、OSPF（開放式最短路徑優先）、IP（網絡之間包的轉換）、ARP（數據鏈路層，IP轉mac輸入要網址 ->DNS通過瀏覽器中域名查找IP地址->瀏覽器給web服務器發送一個  HTTP請求（get，post使用tcp協議）->重定向地址（qq.com變爲www.qq.com）->服務器“處理”請求->  服務器發回一個HTML響應->瀏覽器開始顯示HTML->瀏覽器發送獲取嵌入在HTML中的對象

Ping的整個過程。ICMP報文是什麼。

同一網段：ARP協議查詢mac地址（交換機學習IPmac），通過mac，IP發送ICMP報文要求回覆報文  
不同網段：查詢路由器mac，通過路由器廣播得到目標mac，同理

C/S模式下使用socket通信，幾個關鍵函數

server：socket bind listen accept read write close  
client：socket connect write read close

IP地址分類。

A：0 +7網絡號+24主機號   255.0.0.0  
B：10 +14網絡號+16主機號 255.255.0.0  
C：110 +21網絡號+8主機號 255.255.255.0  
D：1110   E：11110

路由器與交換機區別。

IP，路由選擇   交換機主要是IP與mac轉化

———————————————————數據結構與算法經典面試題———————————————————————————-

鏈表與數組。

隊列和棧，出棧與入棧。

鏈表的刪除、插入、反向。

字符串操作。

Hash表的hash函數，衝突解決方法有哪些。

乘法散列法，除法散列法等    
開放定址法（迭代算法）， 
鏈地址法，再哈希（不同的算法）等

各種排序：

冒泡、選擇、插入、希爾、歸併、快排、堆排、桶排、基數的原理、平均時間複雜度、最壞時間複雜度、空間複雜度、是否穩定。

快排的partition函數與歸併的Merge函數。

對冒泡與快排的改進。

二分查找，與變種二分查找。

二叉樹、B+樹、AVL樹、紅黑樹、哈夫曼樹。

二叉樹的前中後續遍歷：遞歸與非遞歸寫法，層序遍歷算法。

圖的BFS與DFS算法，最小生成樹prim算法與最短路徑Dijkstra算法。

KMP算法。

排列組合問題。

動態規劃、貪心算法、分治算法。（一般不會問到）

大數據處理：類似10億條數據找出最大的1000個數………等等

————————————————————–Android經典面試題———————————————————————————-

GC:

引用計數法：缺點是無法處理循環引用問題
標記-清除法：標記所有從根結點開始的可達對象，缺點是會造成內存空間不連續，不連續的內存空間的工作效率低於連續的內存空間，不容易分配內存
複製算法：將內存空間分成兩塊，每次將正在使用的內存中存活對象複製到未使用的內存塊中，之後清除正在使用的內存塊。算法效率高，但是代價是系統內存摺半。適用於新生代(存活對象少，垃圾對象多)
標記－壓縮算法：標記－清除的改進，清除未標記的對象時還將所有的存活對象壓縮到內存的一端，之後，清理邊界所有空間既避免碎片產生，又不需要兩塊同樣大小的內存快，性價比高。適用於老年代。
分代

Activity與Fragment的生命週期。

Acitivty的四中啓動模式與特點。

Activity緩存方法。

Service的生命週期，兩種啓動方法，有什麼區別。

怎麼保證service不被殺死。

廣播的兩種註冊方法，有什麼區別。

Intent的使用方法，可以傳遞哪些數據類型。

ContentProvider使用方法。

Thread、AsycTask、IntentService的使用場景與特點。

五種佈局： FrameLayout 、 LinearLayout 、 AbsoluteLayout 、 RelativeLayout 、TableLayout 各自特點及繪製效率對比。

Android的數據存儲形式。

Sqlite的基本操作。

Android中的MVC模式。

Merge、ViewStub的作用。

Json有什麼優劣勢。

動畫有哪三類，各有什麼特點？

Handler、Loop消息隊列模型，各部分的作用。

怎樣退出終止App。

Android怎麼加速啓動Activity。

Android內存優化方法：ListView優化，及時關閉資源，圖片緩存等等。

Android中弱引用與軟引用的應用場景。

Bitmap的四中屬性，與每種屬性隊形的大小。

View與View Group分類。自定義View過程：onMeasure()、onLayout()、onDraw()。

Touch事件分發機制。

Android長連接，怎麼處理心跳機制。

Zygote的啓動過程。

Android IPC:Binder原理。

你用過什麼框架，是否看過源碼，是否知道底層原理。

Android5.0、6.0新特性。

請解釋下在單線程模型中Message,Handler,Message Queue,Looper之間的關係。

拿主線程來說，主線程啓動時會調用Looper.prepare()方法，會初始化一個Looper，放入Threadlocal中，接着調用Looper.loop()不斷遍歷Message Queue，  Handler的創建依賴與當前線程中的Looper，如果當前線程沒有Looper則必須調用Looper.prepare()。Handler , sendMessage到MessageQueue，Looper不斷 從MessageQueue中取出消息，回調handleMessage方法。

如果有個100M大的文件，需要上傳至服務器中，而服務器form表單最大隻能上傳2M，可以用什麼方法。

這個問題不是很明確我覺得，首先來說使用http協議上傳數據，特別在android下，跟form沒什麼關係。傳統的在web中，在form中寫文件上傳，其實瀏覽器所做 的就是將我們的數據進行解析組拼成字符串，以流的方式發送到服務器，且上傳文件用的都是POST方式，POST方式對大小沒什麼限制。  回到題目，可以說假設每次真的只能上傳2M，那麼可能我們只能把文件截斷，然後分別上傳了

內存溢出和內存泄漏有什麼區別？何時會產生內存泄漏？內存優化有哪些方法？

內存溢出通俗理解就是軟件（應用）運行需要的內存，超出了它可用的最大內存。 內存泄漏就是我們對某一內存空間的使用，使用完成後沒有釋放。  內存優化：Android中容易內存溢出的部分，就是圖片的加載，我們可以使用圖片的壓縮加上使用LruCache緩存的目的來控制圖片所能夠使用的內存。  還有對於比較耗資源的對象及時的關閉，例如Database Conn , 各種傳感器 ， Service 等等。

AsyncTask使用在哪些場景？它的缺陷是什麼？如何解決？

AsyncTask 運用的場景就是我們需要進行一些耗時的操作，耗時操作完成後更新主線程，或者在操作過程中對主線程的UI進行更新。  缺陷：AsyncTask中維護着一個長度爲128的線程池，同時可以執行5個工作線程，還有一個緩衝隊列，當線程池中已有128個線程，緩衝隊列已滿時，如果 此時向線程提交任務，將會拋出RejectedExecutionException。  解決：由一個控制線程來處理AsyncTask的調用判斷線程池是否滿了，如果滿了則線程睡眠否則請求AsyncTask繼續處理。

assest文件夾裏放文件，對於文件的大小有沒有限制？

assets目錄更像一個附錄類型的目錄，Android不會爲這個目錄中的文件生成ID並保存在R類當中，因此它與Android中的一些類和方法兼容度更低。  同時，由於你需要一個字符串路徑來獲取這個目錄下的文件描述符，訪問的速度會更慢。但是把一些文件放在這個目錄下會使一些操作更加方便，  比方說拷貝一個數據庫文件到系統內存中。要注意的是，你無法在Android XML文件中引用到assets目錄下的文件，只能通過AssetManager來訪問  這些文件。數據庫文件和遊戲數據等放在這個目錄下是比較合適的。另外，網上關於assets和raw的資料都千篇一律了，因此關於這兩者中單個文件  大小不能超過1M的**錯誤**描述也在傳播，即如果讀取超過1M的文件會報"Data exceeds UNCOMPRESS_DATA_MAX (1314625 vs 1048576)"的  IOException，還引申出種種解決方案。個人認爲不應該有這樣的限制，爲了驗證這個說法寫了個Demo，發現將近5M的壓縮包在assets和raw中  都能正常訪問，因此在這裏糾正一下，理論上只要打包不超過Android APK 50M大小的限制都是沒有問題的。當然了，不排除是Android很早期的 
時候因爲設備硬件原因aapt在編譯的時候對這兩個文件夾大小做出了限制，如果是這樣，較新版的ADT應該不會出現這種情況。 來自：http://my.eoe.cn/futurexiong/archive/5350.html

啓動一個程序，可以主界面點擊圖標進入，也可以從一個程序中跳轉過去，二者有什麼區別？

是因爲啓動程序（主界面也是一個app），發現了在這個程序中存在一個設置爲<category android:name="android.intent.category.LAUNCHER" />的activity,  所以這個launcher會把icon提出來，放在主界面上。當用戶點擊icon的時候，發出一個Intent： Intent intent =  mActivity.getPackageManager().getLaunchIntentForPackage(packageName); mActivity.startActivity(intent);     跳過去可以跳到任意允許的頁面，如一個程序可以下載，那麼真正下載的頁面可能不是首頁（也有可能是首頁），這時還是構造一個Intent，startActivity.  這個intent中的action可能有多種view,download都有可能。系統會根據第三方程序向系統註冊的功能，爲你的Intent選擇可以打開的程序或者頁面。所以唯一的一點 不同的是從icon的點擊啓動的intent的action是相對單一的，從程序中跳轉或者啓動可能樣式更多一些。本質是相同的。

程序之間的親和性的理解。

1、默認情況下一個應用的所有Activity都是具有相同的affinity，都是從application中繼承，application的affinity默認就是manifest的包名。  
2、affinity對Activity來說，就像是身份證一樣，可以告訴所在的Task，自己屬於其中的一員。
3、應用場合： 
    a:根據affinity重新爲Activity選擇合適的宿主Task; 
    b:與allowTaskReparenting屬性配合;  
    c:啓動Activity使用Intent設置了FLAG_ACTIVITY_NEW_TASK標記

同一個程序，但不同的Activity是否可以放在不同的Task任務棧中？

1、不設置Activity的android:configChanges時，切屏會重新調用各個生命週期，切橫屏時會執行一次，切豎屏時會執行兩次  
2、設置Activity的android:configChanges="orientation"時，切屏還是會重新調用各個生命週期，切橫、豎屏時只會執行一次  
3、設置Activity的android:configChanges="orientation|keyboardHidden"時，切屏不會重新調用各個生命週期，只會執行onConfigurationChanged方法

AIDL的全稱是什麼？如何工作？

全稱是：Android Interface Define Language  
在Android中, 每個應用程序都可以有自己的進程. 在寫UI應用的時候, 經常要用到Service. 在不同的進程中, 怎樣傳遞對象呢? 
顯然, Java中不允許跨進程內存共享.  因此傳遞對象, 只能把對象拆分成操作系統能理解的簡單形式, 以達到跨界對象訪問的目的. 在J2EE中,採用RMI的方式, 可以通過序列化傳遞對象. 在Android中, 則  採用AIDL的方式. 理論上AIDL可以傳遞Bundle,實際上做起來卻比較麻煩。 
AIDL(AndRoid接口描述語言)是一種藉口描述語言; 編譯器可以通過aidl文件生成一段代碼，通過預先定義的接口達到兩個進程內部通信進程的目的. 如果需要 在一個Activity中, 訪問另一個Service中的某個對象, 需要先將對象轉化成AIDL可識別的參數(可能是多個參數), 然後使用AIDL來傳遞這些參數, 在消息的接收端, 使用  這些參數組裝成自己需要的對象.AIDL的IPC的機制和COM或CORBA類似, 是基於接口的，但它是輕量級的。它使用代理類在客戶端和實現層間傳遞值. 
如果要使用AIDL,   需要完成2件事情: 
1. 引入AIDL的相關類.; 
2. 調用aidl產生的class. 
AIDL的創建方法:  AIDL語法很簡單,可以用來聲明一個帶一個或多個方法的接口，也可以傳遞參數和返回值。 由於遠程調用的需要, 這些參數和返回值並不是任何類型. 
下面是些AIDL支持的數據類型:  
1. 不需要import聲明的簡單Java編程語言類型(int,boolean等) 
2. String, CharSequence不需要特殊聲明  
3. List, Map和Parcelables類型, 這些類型內所包含的數據成員也只能是簡單數據類型, String等其他比支持的類型.  
4. (另外: 我沒嘗試Parcelables, 在Eclipse+ADT下編譯不過, 或許以後會有所支持

dvm的進程和Linux的進程, 應用程序的進程是否爲同一個概念

Dvm的進程是dalivk虛擬機進程,每個android程序都運行在自己的進程裏面,每個android程序系統都會給他分配一個單獨的liunx uid(user id), 每個dvm都是linux裏面的一個進程.所以說這兩個進程是一個進程.

什麼是Activity?

四大組件之一,一般的,一個用戶交互界面對應一個activity, activity 是Context的子類,同時實現了window.callback和keyevent.callback, 可以處理與窗體用戶交互的事件. 我開發常用的的有ListActivity  , PreferenceActivity 等…如果界面有共同的特點或者功能的時候,還會自己定義一個BaseActivity

請描述一下Activity生命週期

生命週期描述的是一個類 從創建(new出來)到死亡(垃圾回收)的過程中會執行的方法..    在這個過程中 會針對不同的生命階段會調用不同的方法        Activity從創建到銷燬有多種狀態，從一種狀態到另一種狀態時會激發相應的回調方法，這些回調方法包括：oncreate ondestroy onstop onstart onresume onpause    其實這些方法都是兩兩對應的，onCreate創建與onDestroy銷燬；    onStart可見與onStop不可見；onResume可編輯（即焦點）與onPause；    這6個方法是相對應的，那麼就只剩下一個onRestart方法了，這個方法在什麼時候調用呢？   

答案就是：在Activity被onStop後，但是沒有被onDestroy，在再次啓動此Activity時就調用onRestart（而不再調用onCreate）方法；    如果被onDestroy了，則是調用onCreate方法。    最後講自己項目中的經驗,比如說豆瓣客戶端每次進入某個界面的時候要刷新列表,這個刷新列表的操作 就放在onStart()的方法裏面.這樣保證每次用戶看到的數據都是最新的.        多媒體播放, 播放來電話. onStop() 視頻, 視頻聲音設置爲0 , 記錄視頻播放的位子    onStart() 根據保存的狀態恢復現場.        在讀文檔的時候 還發現 activity還有兩個方法 onPostResume() 和 OnPostCreate()這兩個生命週期的方法,不過開發的時候沒有用到過

兩個Activity之間跳轉時必然會執行的是哪幾個方法

一般情況比如說有兩個activity,分別叫A,B ,當在A裏面激活B組件的時候, A 會調用 onPause()方法,然後B 調用onCreate() ,onStart(), OnResume() , 這個時候B覆蓋了窗體, A會調用onStop()方法.  如果B呢 是個透明的,或者是對話框的樣式, 就不會調用onStop()方法

橫豎屏切換時候Activity的生命週期。

這個生命週期跟清單文件裏的配置有關係    
1、不設置Activity的android:configChanges時，切屏會重新調用各個生命週期    默認首先銷燬當前activity,然後重新加載            
2、設置Activity的android:configChanges="orientation|keyboardHidden"時，切屏不會重新調用各個生命週期，只會執行onConfigurationChanged方法

如何將一個Activity設置成窗口的樣式

可以自定義一個activity的樣式,詳細見手機衛士的程序詳細信息    
android:theme="@style/FloatActivity"     
E:\day9\mobilesafe\res\values\style

你後臺的Activity被系統回收怎麼辦？如果後臺的Activity由於某原因被系統回收可了，如何在被系統回收之前保存當前狀態？

除了在棧頂的activity,其他的activity都有可能在內存不足的時候被系統回收,一個activity越處於棧底,被回收的可能性越大. 
protected void onSaveInstanceState(Bundle outState) {           
super.onSaveInstanceState(outState);           
outState.putLong("id", 1234567890);   }    
public void onCreate(Bundle savedInstanceState) {    
//判斷 savedInstanceState是不是空.    
//如果不爲空就取出來            
super.onCreate(savedInstanceState);   }

如何退出Activity？如何安全退出已調用多個Activity的Application？

1、拋異常強制退出：    該方法通過拋異常，使程序Force Close。    驗證可以，但是，需要解決的問題是，如何使程序結束掉，而不彈出Force Close的窗口。        
2、記錄打開的Activity：    每打開一個Activity，就記錄下來。在需要退出時，關閉每一個Activity即可。        
3、發送特定廣播：    在需要結束應用時，發送一個特定的廣播，每個Activity收到廣播後，關閉即可。     
4、遞歸退出    在打開新的Activity時使用startActivityForResult，然後自己加標誌，在onActivityResult中處理，遞歸關閉。    
上面是網上的一些做法.    其實 可以通過 intent的flag 來實現.. intent.setFlag(FLAG_ACTIVITY_CLEAR_TOP)激活一個新的activity,然後在新的activity的oncreate方法裏面 finish掉.

service是否在main thread中執行, service裏面是否能執行耗時的操作?

默認情況,如果沒有顯示的指定service所運行的進程, Service和activity是運行在當前app
所在進程的main thread(UI主線程)裏面

兩個Activity之間怎麼傳遞數據？

基本數據類型可以通過.  Intent 傳遞數據     extras.putDouble(key, value)    intent.putExtras(extras)    
Application 全局裏面存放 對象 ,自己去實現自己的application的這個類,基礎系統的application , 每個activity都可以取到    
讓對象實現 implements  Serializable 接口把對象存放到文件上.      
讓類實現Serializable 接口,然後可以通過 ObjectOutputStream ObjectInputStream           //ObjectInputStream           //ObjectOutputStream 
 FileOutputStream fos  =  new  FileOutputStream(new  File("/sdcard/studnet.obj"));               
ObjectOutputStream oos = new ObjectOutputStream(fos);                             
oos.writeObject(new Student());

怎麼讓在啓動一個Activity是就啓動一個service

在activity的onCreate()方法裏面 startService();

同一個程序，但不同的Activity是否可以放在不同的Task任務棧中

比方說在激活一個新的activity時候, 給intent設置flag   
Intent的flag添加FLAG_ACTIVITY_NEW_TASK       
這個被激活的activity就會在新的task棧裏面…

Activity怎麼和service綁定，怎麼在activity中啓動自己對應的service？

bindService().  讓activity能夠訪問到 service裏面的方法構建一個intent對象,    
Intent service = new Intent(this,MyService.class);     
通過bindService的方法去啓動一個服務,           
ServiceConnection  對 象 ( 重 寫 onServiceConnected 和 OnServiceDisconnected方法) 和BIND_AUTO_CREATE.          
private class myconn implements ServiceConnection     {                      
public void onServiceConnected(ComponentName name, IBinder service) {                         
// TODO Auto-generated method stub                         
//可以通過IBinder的對象 去使用service裏面的方法                  }                      
public void onServiceDisconnected(ComponentName name) {                         
// TODO Auto-generated method stub                           
          }                           }

什麼是Service以及描述下它的生命週期。Service有哪些啓動方法，有什麼區別，怎樣停用Service？

在Service的生命週期中，被回調的方法比Activity少一些，只有onCreate, onStart, onDestroy,    onBind和onUnbind。    
通常有兩種方式啓動一個Service,他們對Service生命週期的影響是不一樣的。    
1 通過startService   Service會經歷 onCreate 到onStart，然後處於運行狀態，stopService的時候調用onDestroy方法。 如果是調用者自己直接退出而沒有調用stopService的話，Service會一直在後臺運行。      
2 通過bindService  Service會運行onCreate，然後是調用onBind， 這個時候調用者和Service綁定在一起。調用者退出了，Srevice就會調用onUnbind->onDestroyed方法。       所謂綁定在一起就共存亡了。調用者也可以通過調用unbindService方法來停止服務，這時候Srevice就會調用onUnbind->onDestroyed方法。    需要注意的是如果這幾個方法交織在一起的話，會出現什麼情況呢？    一個原則是Service的onCreate的方法只會被調用一次，就是你無論多少次的startService又bindService，Service只被創建一次。    如果先是bind了，那麼start的時候就直接運行Service的onStart方法，如果先是start，那麼bind的時候就直接運行onBind方法。 如果service運行期間調用了bindService，這時候再調用stopService的話，service是不會調用onDestroy方法的，service就stop不掉了，只能先UnbindService, 再StopService。如果一個service通過startService 被start之後，多次調用startService 的話，service會多次調用onStart方法。多次調用stopService的話，service只會調用一次onDestroyed方法如果一個service通過bindService被start之後，多次調用bindService的話，service只會調用一次onBind方法。 多次調用unbindService的話會拋出異常

不用service，B頁面爲音樂播放，從A跳轉到B，再返回，如何使音樂繼續播放？

這個問題問的很山寨.默認不做任何處理,B裏面的音樂都能播放.    遇到問題, 可以隨機應變,靈活發揮,多考慮些細節,比如說這個題就可以這樣說,說說你對startActivityForResult的理解()    
A開啓B的時候,用startActivityForResult()方法, 
B返回的時候把播放的狀態信息返回給A ,A繼續播放音樂.

什麼是IntentService？有何優點？

普通的service ,默認運行在ui main 主線程        
Sdk給我們提供的方便的,帶有異步處理的service類,   
OnHandleIntent() 處理耗時的操作

什麼時候使用Service？

擁有service的進程具有較高的優先級
官方文檔告訴我們，Android系統會盡量保持擁有service的進程運行，只要在該service已經被啓動(start)或者客戶端連接(bindService)到它。
當內存不足時，需要保持，擁有service的進程具有較高的優先級。
1． 如果service正在調用onCreate,  onStartCommand或者onDestory方法，那麼用於當前service的進程相當於前臺進程以避免被killed。    
2． 如果當前service已經被啓動(start)，擁有它的進程則比那些用戶可見的進程優先級低一些，但是比那些不可見的進程更重要，這就意味着service一般不會被killed.    
3． 如果客戶端已經連接到service (bindService),那麼擁有Service的進程則擁有最高的優先級，可以認爲service是可見的。 
4． 如果service可以使用startForeground(int, Notification)方法來將service設置爲前臺狀態，那麼系統就認爲是對用戶可見的，並不會在內存不足時killed。    
如果有其他的應用組件作爲Service,Activity等運行在相同的進程中，那麼將會增加該進程的重要性。           
1.Service的特點可以讓他在後臺一直運行,可以在service裏面創建線程去完成耗時的操作.           
2.Broadcast receiver捕獲到一個事件之後,可以起一個service來完成一個耗時的操作.           
3.遠程的service如果被啓動起來,可以被多次bind, 但不會重新create.  索愛手機X10i的人臉識別的service可以被圖庫使用,可以被攝像機,照相機等程序使用.

請描述一下Intent 和 Intent Filter

Android 中通過 Intent 對象來表示一條消息，一個 Intent 對象不僅包含有這個消息的目的地，還可以包含消息的內容，這好比一封 Email，其中不僅應該包含收件地址，還可以包含具體的內容。對於一個 Intent 對象，消息“目的地”是必須的，而內容則是可選項。
通過Intent 可以實現各種系統組件的調用與激活.     Intent filter: 可以理解爲郵局或者是一個信箋的分揀系統…    這個分揀系統通過3個參數來識別    Action: 動作       Data: 數據uri      Category : 而外的附加信息    Action 匹配    Action 是一個用戶定義的字符串，用於描述一個 Android 應用程序組件，一個 Intent Filter 可以包含多個 Action。在 AndroidManifest.xml 的 Activity 定義時可以在其 <intent-filter >節點指定一個 Action 列表用於標示 Activity 所能接受的“動作”，
例如：     
<intent-filter > 
<action android:name="android.intent.action.MAIN" />     
<action android:name="cn.itcast.action" />   
……     
</intent-filter> 
如果我們在啓動一個 Activity 時使用這樣的 Intent 對象：     
Intent intent =new Intent();     
intent.setAction("cn.itcast");        
那麼所有的 Action 列表中包含了“cn.itcast”的 Activity 都將會匹配成功。    
Android 預定義了一系列的 Action 分別表示特定的系統動作。這些 Action 通過常量的方式定義在 android.content. Intent中，以“ACTION_”開頭。我們可以在 Android 提供的文檔中找到它們的詳細說明。    
URI 數據匹配    一個 Intent 可以通過 URI 攜帶外部數據給目標組件。在 <intent-filter >節點中，通過 <data/>節點匹配外部數據。    
mimeType 屬性指定攜帶外部數據的數據類型，scheme 指定協議，host、port、path 指定數據的位置、端口、和路徑。如下：     
<data android:mimeType="mimeType" 
android:scheme="scheme"     
android:host="host" 
android:port="port" 
android:path="path"/>    
電話的uri   tel://12345
http://www.baidu.com    
自己定義的uri  itcast://cn.itcast/person/10
如果在 Intent Filter 中指定了這些屬性，那麼只有所有的屬性都匹配成功時 URI 數據匹配纔會成功。    
Category 類別匹配    
<intent-filter >節點中可以爲組件定義一個 Category 類別列表，當 Intent 中包含這個列表的所有項目時 Category 類別匹配纔會成功。    默認是DEFAULT

Intent傳遞數據時，可以傳遞哪些類型數據

1.一般的基本數據類型 Intent .putextra() intent.getextra();               
2.數據的uri, intent.setData() intent.getData();

說說Activity，Intent，Service是什麼關係

麥當勞和麥當娜的關係是什麼關係?           
這種問題,就講下activity,講一下service,說一下 通過intent去激活組件,傳遞數據.           
說自己項目中有這樣一個網絡更新的功能,顯示界面就用的activity, 後臺有個service每隔半小時都去訪問下服務器獲取更新的數據…開啓服務用的是intent來開啓

請描述一下Broadcast Receiver

用於接收系統的廣播通知, 系統會有很多sd卡掛載,手機重啓,廣播通知,低電量,來電,來短信等….     
手機衛士中自定義一個broadcast receiver來獲取短信到來的廣播, 根據黑名單來判斷是否攔截該短信.     
畫畫板生成圖片後,發送一個sd掛載的通知,通知系統的gallery去獲取到新的圖片.

在manifest和代碼中如何註冊和使用 broadcast receiver

 設置廣播接收者的優先級,設置廣播接受者的action名字 等…

請介紹下ContentProvider是如何實現數據共享的

把自己的數據通過uri的形式共享出去                    
需要去實現一個類去繼承ContentProvider           
public class PersonContentProvider extends ContentProvider{          
public boolean onCreate(){                  //..          }    
query(Uri, String[], String, String[], String)    
insert(Uri, ContentValues) 
update(Uri, ContentValues, String, String[])    
delete(Uri, String, String[])   }

請介紹下Android的數據存儲方式

文件  訪問權限.           
數據庫 sqlite           
SharedPreference           
網絡
內容提供者

爲什麼要用ContentProvider？它和sql的實現上有什麼差別

屏蔽數據存儲的細節,對用戶透明,用戶只需要關心操作數據的uri就可以了 
不同app之間共享,操作數據           
Sql也有增刪改查的方法.           
但是contentprovider 還可以去增刪改查本地文件.

請介紹下Android中常用的五種佈局

 FrameLayout（框架佈局），
LinearLayout （線性佈局），
AbsoluteLayout（絕對佈局），
RelativeLayout（相對佈局），
TableLayout（表格佈局）

 FrameLayout        
從屏幕的左上角開始佈局,疊加顯示, 實際應用 播放器的暫停按鈕.          
LinearLayout    
線性佈局，這個東西，從外框上可以理解爲一個div，他首先是一個一個從上往下羅列在屏幕上。每一個LinearLayout裏面又可分爲垂直佈局    （android:orientation="vertical"）和水平佈局（android:orientation="horizontal" ）。當垂直佈局時，每一行就只有一個元素，多個元素依次垂直往下；水平佈局時，只有一行，每一個元素依次向右排列。      
AbsoluteLayout    
絕對佈局猶如div指定了absolute屬性，用X,Y座標來指定元素的位置android:layout_x="20px"    android:layout_y="12px"    指定平板機型的遊戲開發中經常用到絕對佈局    指定機型的平板遊戲開發.          
RelativeLayout        
相對佈局可以理解爲某一個元素爲參照物，來定位的佈局方式。主要屬性有： 相對於某一個元素 
android:layout_below="@id/aaa" 該元素在 id爲aaa的下面        
android:layout_toLeftOf="@id/bbb" 改元素的左邊是bbb   相對於父元素的地方         
android:layout_alignParentLeft="true"  在父元素左對齊        
android:layout_alignParentRight="true" 在父元素右對齊      
TableLayout    
表格佈局類似Html裏面的Table。每一個TableLayout裏面有表格行TableRow，TableRow裏面可以具體定義每一個元素，設定他的對齊方式 android:gravity="" 。    每一個佈局都有自己適合的方式，另外，這五個佈局元素可以相互嵌套應用，做出美觀的界面。   
webview

談談UI中， Padding和Margin有什麼區別

Padding 文字對邊框, margin是控件對父窗體.

 這個題沒看懂… widget可以理解成桌面小控件, 也可以理解成 某個button, imageview這樣的控件…

請解釋下在單線程模型中Message、Handler、Message Queue、Looper之間的關係。