面向對象與面向過程：

面向過程就是分析出解決問題所需要的步驟，然后用函數把這些步驟一步一步實現，使用的時候一個一個依次調用就可以了。
面向對象是把構成問題事務分解成各個對象，建立對象的目的不是為了完成一個步驟，而是為了描敘某個事物在整個解決問題的步驟中的行為。

代碼混淆：亦稱花指令，是將計算機程序的代碼，轉換成一種功能上等價，但是難于閱讀和理解的形式的行為，防止他人可以輕松的反編譯出你的代碼。

面向對象3特征：封裝、繼承、多態性。

? ? 作用域? ? ? 當前類?同一package? 子孫類 其他package

? ? ? ?public? ? ? ?√? ? ? ? ? ? ??√ ? ? ? ?? ? ? ?√ ? ? ? ? ? ? ??√

? ? ? ?protected √ ? ? ? ?? ? ? ?√ ? ? ? ?? ? ? ?√ ? ? ? ?? ? ? ?×

? ? ? ?default? ? ?√ ? ? ? ?? ? ? ?√ ? ? ? ?? ? ? ?× ? ? ? ?? ? ? ?×

? ? ? ?private ? ? √ ? ? ? ?? ? ? ?× ? ? ? ?? ? ? ?×? ? ? ?? ? ? ? ×

Java與c、c++編碼到運行的區別：

Java：.java文件->javac(編譯器)->.class(字節碼文件)->jvm運行，java運行在虛擬機上，可做到跨平臺運行。

c、c++：直接編譯成可執行文件，無法跨平臺，不同的操作系統的標準不一樣。

JAVA方法的形參的傳遞機制：值傳遞

值傳遞時，因為修改的是形參地址的內容，所以不會對實參產生影響，地址（引用）傳遞時，修改形參的屬性，并不是直接就把形參的地址里的內容覆蓋（因為形參地址里存的只是個地址，沒有什么屬性），而是先從形參地址里取出里面的內容，即形參和實參共同指向的地址，然后再對那個地址進行操作，這樣，因為實參也指向那個地址，所以實參的屬性也會發生改變。對于重新給形參賦值，這時是在形參的地址里重新存入一個新的地址，此時形參與實參不再指向同一個地址，所以形參的任何變化都不會對實參造成影響。這也就是為什么在函數里不能改變實參的指向的原因。

int[] a={1,2,3} 和 int[] a = new int[]{1,2,3}

數組對象一樣放在堆里，java的數組變量是一種引用型的變量，數組變量并不是數組本身。他只是指向堆內存中的數組對象。
所有局部變量都是存放在棧內存中，不管其是基本類型的變量還是引用類型的變量，都是存儲在各自的方法棧區中；但引用類型變量所引用的對象（包括數組、普通java對象）則總是存儲在堆內存中。

從低位類型到高位類型自動轉換，從高位類型到低位類型需要強制類型轉換：

• 布爾型和其它基本數據類型之間不能相互轉換；?
• byte型可以轉換為short、int、、long、float和double；?
• short可轉換為int、long、float和double；?
• char可轉換為int、long、float和double；?
• int可轉換為long、float和double；?
• long可轉換為float和double；?
• float可轉換為double；?

將long值b強制轉換為int：int a = (int)b

基本數據類型占字節及位數：

• 字節byte：用來計量存儲容量的一種計量單位；位bit? ? ? 一個字節等于8位 ?1byte = 8bit

整型：

• byte:1個字節 8位 -128~127
• short ：2個字節 16位
• int ：4個字節 32位
• long：8個字節 64位

浮點型：

• float：4個字節 32 位
• double ：8個字節 64位

注：默認的是double類型，如3.14是double類型的，加后綴F（3.14F）則為float類型的。

char類型：

• char：2個字節 16位，所以一個char類型的可以存儲一個漢字。

Boolean 類型

• boolean: true or false

算術運算規則

基本就是先轉換為高位數據類型，再參加運算，結果也是最高位的數據類型；

byte short char運算會轉換為Int；

String類是final類

“對String對象的任何改變都不影響到原對象，相關的任何change操作都會生成新的對象”。

public class Test{public static void main(String[] args){String a = "aaaa";String b = a.replace('a', 'b');System.out.println(a);System.out.print(b);} }

當對String類對象進行substring()，replace()等，應該賦值給新的String對象，因為a還是原來的內容。

String str="hello world"和String str=new String("hello world")的區別：

public class Test{public static void main(String[] args){String a = new String("aaaa");String b = new String("aaaa");String c = "aaaa";System.out.println(a==b);System.out.println(a.equals(b));System.out.println(a==c);System.out.println(a.equals(c));} }

String c = "aaaa";在編譯期間生成了字面常量和符號引用，運行期間字面常量"aaaa"被存儲在運行時常量池（當然只保存了一份）。通過這種方式來將String對象跟引用綁定的話，JVM執行引擎會先在運行時常量池查找是否存在相同的字面常量，如果存在，則直接將引用指向已經存在的字面常量；否則在運行時常量池開辟一個空間來存儲該字面常量，并將引用指向該字面常量。通過new關鍵字來生成對象是在堆區進行的，而在堆區進行對象生成的過程是不會去檢測該對象是否已經存在的。因此通過new來創建對象，創建出的一定是不同的對象，即使字符串的內容是相同的。

"=="和eqals區別：

• equals：String類的equals方法只比較內容，所以上面equals返回true。Object類的equals方法則比較他們在內存中的存放地址。
• ==：基本數據類型，byte,short,char,int,long,float,double,boolean?他們之間的比較，應用雙等號（==）,比較的是他們的值。當用來比較類對象時，比較的是他們在內存中的存放地址，所以除非是引用自同一個new的對象，否則都為false。

StringBuilder和StringBuffer類區別：

StringBuilder和StringBuffer類擁有的成員屬性以及成員方法基本相同，區別是StringBuffer類的成員方法前面多了一個關鍵字：synchronized，StringBuffer類是線程安全的

序列化和反序列化

在很多應用中，需要對某些對象進行序列化，讓它們離開內存空間，入住物理硬盤，以便長期保存。當兩個進程在進行遠程通信時，彼此可以發送各種類型的數據。無論是何種類型的數據，都會以二進制序列的形式在網絡上傳送。發送方需要把這個Java對象轉換為字節序列，才能在網絡上傳送；接收方則需要把字節序列再恢復為Java對象。

• 把對象轉換為字節序列的過程稱為對象的序列化。
• 把字節序列恢復為對象的過程稱為對象的反序列化。
• java.io.ObjectOutputStream代表對象輸出流，它的writeObject(Object obj)方法可對參數指定的obj對象進行序列化，把得到的字節序列寫到一個目標輸出流中。
• java.io.ObjectInputStream代表對象輸入流，它的readObject()方法從一個源輸入流中讀取字節序列，再把它們反序列化為一個對象，并將其返回。

transient關鍵字

只能修飾變量，將不需要序列化的屬性前添加關鍵字transient，序列化對象的時候，這個屬性就不會被序列化。保證屬性不會被傳遞，安全。

volatile關鍵字

所有線程的共享變量都存儲在主存（既內存）中，每一個線程都有一個獨有的工作內存，每個線程不直接操作在主內存中的變量，而是將主內存上變量的副本放進自己的工作內存中，只操作工作內存中的數據。當修改完畢后，再把修改后的結果放回到主內存中。這就導致多線程的環境下可能會出現臟數據，加上volatile關鍵字修飾的話，它可以保證當線程對變量值做了變動之后，會立即刷回到主內存中，這樣在任何時刻，線程總是會看到變量的同一個值。

缺點：保證了可見性和有序性，但是原子性無法保證，無法代替Synchronize關鍵字。

例如：兩個線程的一個共享volatile變量i，都進行i++循環操作，i=0，此時線程A進行i++，i=1了，而B線程已經讀取了i=0，所以B再i++，也是i=1，造成數據不準確。

為了保證數據準確性一般使用Synchronize、lock或者AtomicInteger。AtomicInteger采用CAS保證線程安全。

static關鍵字

• 不能修飾外部類，只有修飾內部類。
• 靜態的方法不能重寫，直接通過類名調用。靜態方法里調用外部類的只能是靜態變量和靜態方法
• 靜態變量在JVM初始化階段就被賦值
• 靜態代碼塊在靜態變量后執行。

類初始化的順序：

父類靜態變量->父類靜態代碼塊->子類靜態變量->子類靜態代碼塊->父類普通變量->父類普通代碼塊->父類構造函數->子類普通變量->子類普通代碼塊->子類構造函數

假設類A有靜態內部類B和非靜態內部類C，創建B和C的區別為：
A a=new A();
A.B b=new A.B();
A.C c=a.new C();

final關鍵字

• final修飾類不可以被繼承，但是可以繼承其他類。
• final修飾的變量稱為常量，這些變量只能賦值一次。
• final修飾的方法，不可以重寫，但可以繼承使用。

final、finally、finalize的區別與用法

• final：java中的關鍵字，修飾符。
• finally：java的異常處理機制最后一步。在try catch塊里return的時候，finally也會被執行。System.exit(0)是終止Java虛擬機JVM的，finally不會執行。
• finalize：Java中的一個方法名。finalize是在對象回收前做一些清掃工作，以及可清理棧上的內存。這個方法是由垃圾收集器在確定這個對象沒被引用時對這個對象調用的。它是在Object類中定義的，因此所的類都繼承了它。子類覆蓋finalize()方法以整理系統資源或者執行其他清理工作。finalize()方法是在垃圾收集器刪除對象之前對這個對象調用的。

try - with - resource

jdk1.7引入的try with resources語法糖式寫法。try-with-resources 語句確保了每個資源在語句結束時關閉。所有實現了 java.lang.AutoCloseable 接口（其中，它包括實現了 java.io.Closeable 的所有對象），可以使用作為資源。

public class Demo { public static void main(String[] args) {try(Resource res = new Resource()) {res.doSome();} catch(Exception ex) {ex.printStackTrace();}} }class Resource implements AutoCloseable {void doSome() {System.out.println("do something");}@Overridepublic void close() throws Exception {System.out.println("resource is closed");} }執行輸出如下： do something resource is closed

在 try 語句中，可以創建多個資源，中間用；隔開，越是最后使用的資源，越是最早被關閉。

try(ResourceSome some = new ResourceSome();ResourceOther other = new ResourceOther())

抽象類與接口區別：

• 抽象類要被子類繼承，接口要被類實現。
• 接口只能做方法聲明，抽象類中可以作方法聲明，也可以做方法實現。
• 接口可以extends接口，而不能implement。
• 非抽象類implement接口，extends抽象類就必須實現所有方法。

匿名類又稱匿名內部類：

new 類名/接口名/抽象類名(){定義子類/實現類的內容}

重載（Overload）和重寫（Override）的區別？

重載發生在一個類中，同名的方法如果有不同的參數列表（參數類型不同、參數個數不同或者二者都不同）則視為重載；

重寫：

發生在父類與子類之間

方法名，參數列表，返回類型（除過子類中方法的返回類型是父類中返回類型的子類）必須相同

訪問修飾符的限制一定要大于或等于被重寫方法的訪問修飾符（public>protected>default>private)

重寫方法一定不能拋出新的檢查異?；蛘弑缺恢貙懛椒ㄉ昝鞲訉挿旱臋z查型異常

多態存在的三個條件

靜態多態：重載

動態多態：

• 有繼承關系　　
• 子類重寫父類方法　　
• 父類引用指向子類對象

多態的實現

方法表：在JVM執行Java字節碼時，類型信息被存放在方法區中，通常為了優化對象調用方法的速度，方法區的類型信息中增加一個指針，該指針指向一張記錄該類方法入口的表（稱為方法表），表中的每一項都是指向相應方法的指針。

方法表結構：方法表中最先存放的是Object類的方法，接下來是該類的父類的方法，最后是該類本身的方法。這里關鍵的地方在于，如果子類改寫了父類的方法，那么子類和父類的那些同名方法共享一個方法表項。排列特性（Object——父類——子類），使得方法表的偏移量總是固定的。

多態的實例方法調用實際上有兩種指令：

• invokevirtual指令用于調用聲明為類的方法；
• invokeinterface指令用于調用聲明為接口的方法。

靜態方法是由虛擬機指令invokestatic調用的，私有方法和構造函數則是由invokespecial指令調用，只有被invokevirtual和invokeinterface指令調用的方法才會在方法表中出現。

invokevirtual ：

先從操作棧中找到對象的實際類型 class；

找到 class 中與被調用方法簽名相同的方法，如果有訪問權限就返回這個方法的直接引用，如果沒有訪問權限就報錯 java.lang.IllegalAccessError ；

如果第 2 步找不到相符的方法，就去搜索 class 的父類，按照繼承關系自下而上依次執行第 2 步的操作；

如果第 3 步找不到相符的方法，就報錯 java.lang.AbstractMethodError ；

如果子類覆蓋了父類的方法，則在多態調用中，即使將子類對象聲明為父類類型，動態綁定過程會首先確定實際類型是子類，從而先搜索到子類中的方法。這個過程便是方法覆蓋的本質。

invokeinterface：

因為?Java?類是可以同時實現多個接口的，而當用接口引用調用某個方法的時候，情況就有所不同了。

Java 對于接口方法的調用是采用搜索方法表的方式，因為每次接口調用都要搜索方法表，所以從效率上來說，接口方法的調用總是慢于類方法的調用的。

動態編譯與靜態編譯

• 靜態編譯：一次性編譯。在編譯的時候把你所有的模塊都編譯進去。
• 動態編譯：按需編譯。程序在運行的時候，用到那個模塊就編譯哪個模塊。

泛型的意義在于

適用于多種數據類型執行相同的代碼（代碼復用）

泛型中的類型在使用時指定，不需要強制類型轉換（類型安全，編譯器會檢查類型）

public class GenericClass<T> {private T data;public T getData() {return data;}public void setData(T data) {this.data = data;}public static void main(String[] args) {GenericClass<String> genericClass=new GenericClass<>();genericClass.setData("Generic Class");System.out.println(genericClass.getData());} }

限定通配符包括兩種：

表示類型的上界，格式為：<？ extends T>，即類型必須為T類型或者T子類

表示類型的下界，格式為：<？ super T>，即類型必須為T類型或者T的父類

非限定通配符：類型為<T>,可以用任意類型來替代。

反射

JAVA反射機制是在運行狀態中，對于任意一個類，都能夠知道這個類的所有屬性和方法；對于任意一個對象，都能夠調用它的任意一個方法和屬性；這種動態獲取的信息以及動態調用對象的方法的功能稱為Java語言的反射機制。

要想解剖一個類，必須先要獲取到該類的字節碼文件對象。既Class clz = Class.forName("包名.類名");

反射就是在運行時才知道要操作的類是什么，并且可以在運行時獲取類的完整構造，并調用對應的方法。

反射就是把Java類中的各種成分映射成一個個的Java對象。

//獲取類的 Class 對象實例 Class clz = Class.forName("包名.類名"); //根據 Class 對象實例獲取 Constructor 對象 Constructor phoneConstructor = clz.getConstructor(); //使用 Constructor 對象的 newInstance 方法獲取反射類對象 Object phoneObj = phoneConstructor.newInstance(); //獲取方法的 Method 對象 Method setPriceMethod = clz.getMethod("setPrice", int.class); //利用 invoke 方法調用方法 setPriceMethod.invoke(phoneObj, 6000);

new與反射區別

new屬于靜態編譯，而反射屬于動態編譯，new時所有模塊都加載了，而反射是用到的時候才加載。

new出來的對象，無法反問它的私有屬性，而反射可以（通過setAccessible（）取訪問）

new關鍵字是強類型的，效率相對較高。 反射是弱類型的，效率低。

反射提供了一種更加靈活的方式創建對象，得到對象的信息。EventBus框架，通過反射獲取類中"onEvent"開頭的訂閱方法。

?刪除目錄下的所有文件及子目錄下所有文件

private boolean deleteDir(String dir) {File file = new File(dir);boolean delete ;if (file.isDirectory()) {String[] children = file.list();if(children.length>0){/**遞歸刪除目錄中的子目錄下*/for (int i=0; i<children.length; i++) {boolean success = deleteDir(dir+"/"+children[i]);if (!success) {return false;}}} } return file.delete();}

單鏈表逆置

//單鏈表定義ListNode{int value;ListNode next; };//單鏈表逆置實現 ListNode ReverseList(ListNode head) {if (head == null||head.next == null){retrun pHead;}ListNode finalList = null;ListNode originList = head;while(originList != null){ListNode tempList = originList; // 步驟①originList = originList.next; // 步驟②tempList.next = finalList; // 步驟③finalList = tempList;}return finalList; }

排序算法：

桶排序：

• 平均時間復雜度：O(n + k)
• 最佳時間復雜度：O(n + k)
• 最差時間復雜度：O(n ^ 2)

public void bucketSort(int[] a){List<Integer> bucket[] = new ArrayList[10];for(int i=0; i < a.length ; i++){int temp = a[i]/10000;if(bucket[temp] == null){bucket[temp] = new ArrayList<Integer>();}bucket[temp].add(a[i]);}//對桶內各個元素進行排序for(int j=0;j<10;j++){intsertSort(bucket[j]);printList(bucket[j]);}}private void printList(List<Integer> list) {while(list.size()>0){System.out.print(list.remove(0) +"\t");}}private void intsertSort(List<Integer> list) {Collections.sort(list);}

插入排序：

直接插入排序基本思想是每一步將一個待排序的記錄，插入到前面已經排好序的有序序列中去，直到插完所有元素為止。

當數據正序時，執行效率最好，每次插入都不用移動前面的元素，時間復雜度為O(N)。
當數據反序時，執行效率最差，每次插入都要前面的元素后移，時間復雜度為O(N^2)。

希爾排序：

第一趟排序中，通過計算gap1=N/2（即10/2），將10個元素分為5組，即（9,4），（1,8），（2,6），（5,3），（7,5），然后對每組內的元素進行插入排序。
第二趟排序中，把上次的 gap 縮小一半，即 gap2 = gap1 / 2 = 2 (取整數)。這樣每相隔距離為 2 的元素組成一組，可以分為 2 組。分組后依舊對每組的元素進行插入排序。
第三趟排序中，再次把 gap 縮小一半，即gap3 = gap2 / 2 = 1。 這樣相隔距離為 1 的元素組成一組，即只有一組。再進行一次插入排序。
需要注意的是，圖中有兩個相等數值的元素 5 和 5 。我們可以清楚的看到，在排序過程中，兩個元素位置交換了。所以，希爾排序是不穩定的算法。

時間復雜度為O(N^(1.3—2))

冒泡排序算法：
1.比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
2.對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最后一對。在這一點，最后的元素會是最大的數。

其時間復雜度依然為O(N^2)

選擇排序:
1.從待排序序列中，找到最小的元素；
2.如果最小元素不是待排序序列的第一個元素，將其和待排序序列的第一個元素互換；

時間復雜度為 O(N*2)

快排O(n*logn)：

import java.util.Arrays;public class Solution {public static void main(String[] args) {quickSort(new int[]{39,28,55,87,66,3,17,39});}public static void quickSort(int[] arr){quickSort(arr,0,arr.length-1);System.out.println(Arrays.toString(arr));}public static void quickSort(int[] arr,int left,int right){int middle;if(left < right){middle = partition(arr,left,right);quickSort(arr,left,middle-1);quickSort(arr,middle+1,right);}}public static int partition(int[] arr,int left,int right){int pivot = arr[left];while(left < right){while(left<right && arr[right] >= pivot)right--;arr[left] = arr[right];while(left < right && arr[left]<= pivot)left++;arr[right] = arr[left];}arr[left] = pivot;return left;} }

遞歸通常用棧來實現。

守護進程

在linux系統中，我們會發現在系統啟動的時候有很多的進程就已經開始跑了，也稱為服務，這也是我們所說的守護進程。

守護進程是脫離于終端并且在后臺運行的進程，脫離終端是為了避免在執行的過程中 的信息在終端上顯示，并且進程也不會被任何終端所產生的終端信息所打斷。守護進程一般的生命周期是系統啟動到系統停止運行。

異常：

所有的異常都是繼承Throwable的，自定義異常不可以繼承自Error。

Error

Error及其子類用來描述Java運行系統中的內部錯誤以及資源耗盡的錯誤，是程序無法處理的錯誤，這類錯誤比較嚴重。這類的大多數錯誤與代碼編寫者執行的操作無關，如，運行代碼時，JVM（Java虛擬機）出現的問題，例如，Java虛擬機運行錯誤（Virtual MachineError），當 JVM 不再有繼續執行操作所需的內存資源時，將出現 OutOfMemoryError。

Exception：可以通過捕捉處理使程序繼續執行，是程序自身可以處理的異常，也稱為非致命性異常類。

異常與錯誤的區別是：異?？梢酝ㄟ^程序自身捕捉處理，而錯誤是程序自身無法處理的。

throws：通常被用在聲明方法時，用來指定方法可能拋出的異常，多個異常可使用逗號分隔。throws關鍵字將異常拋給上一級，如果不想處理該異常，可以繼續向上拋出，但最終要有能夠處理該異常的代碼。

throw：通常用在方法體中或者用來拋出用戶自定義異常，并且拋出一個異常對象。程序在執行到throw語句時立即停止，如果要捕捉throw拋出的異常，則必須使用try-catch語句塊或者try-catch-finally語句。

ThreadLocal

ThreadLocal為解決多線程程序的并發問題提供了一種新的思路，每個線程只能獲取到自己線程的數據，多線程下也不會產生沖突。

ThreadLocal的接口方法

//設置當前線程的線程局部變量的值。 public void set(T value) {Thread t = Thread.currentThread();ThreadLocalMap map = getMap(t);if (map != null)map.set(this, value);elsecreateMap(t, value); }public Object get() 該方法返回當前線程所對應的線程局部變量。public void remove() 將當前線程局部變量的值刪除，目的是為了減少內存的占用，該方法是JDK 5.0新增的方法。 需要指出的是，當線程結束后，對應該線程的局部變量將自動被垃圾回收， 所以顯式調用該方法清除線程的局部變量并不是必須的操作，但它可以加快內存回收的速度。

在ThreadLocal類中有一個ThreadLocalMap，用于存儲每一個線程的變量副本，Map中元素的key為線程對象，而值對應線程的變量副本。

應用：

在進行對象跨層傳遞的時候，使用ThreadLocal可以避免多次傳遞，打破層次間的約束。

線程間數據隔離

進行事務操作，用于存儲線程事務信息。

數據庫連接，Session會話管理。

URI與URL

URL 比較實體?? 表示一個具體的

URI 比較抽象 表示一個相對的意思

URL --?? 比如?http://www.baidu.com/124/123??? 是一個絕對的路徑

URI -- 比如 /124/123 是一個相對的路徑

File實現了?Serializable，可以用Intent傳遞。

四種啟動模式：

Standard? ：普通activity

SingleTop（實例在棧頂不會新建）：展示推送過來的消息

SingleTask（有實例則移到棧頂，并把它上面的activity出棧。）：程序入口等啟動頁面

SingleInstance（創建一個新的任務棧，并且這個任務棧只有他一個Activity）：獨立于程序的activity·

Activity A跳轉到B：

A：onPause()

B: onCreate() onStart() onResume()? 或 onRestart() onStart()? onResume()

A:? onStop()

onSaveInstanceState方法

• onSaveInstanceState() 方法的主要目的是保存和 Activity 的狀態有關的數據，當系統在銷毀 Activity 時，如果它希望 Activity 下次出現的樣子跟之前完全一樣，那么它就會調用onSaveInstanceState()，否則就不調用。能夠通過 onCreate(Bundle) 或者onRestoreInstanceState(Bundle) 來恢復其界面狀態。
• onSaveInstanceState() 方法并不是永遠都會調用。比如，當用戶在一個 Activity 點擊返回鍵時，就不會調用，因為用戶此時明確知道這個 Activity 是要被銷毀的，并不期望下次它的樣子跟現在一樣，所以就不用調用onSaveInstanceState()。
• 在onPause()、onStop() 以及 onDestroy() 中需要保存的是那些需要永久化的數據，而不是保存用于恢復狀態的數據，狀態數據有專門的方法：onSaveInstanceState()。數據保存在一個 Bundle 中，Bundle 被系統永久化。當再調用 Activity 的onCreate()時，原先保存的 Bundle就被傳入，以恢復上一次臨死時的模樣，如果上次被銷毀時沒有保存 Bundle，則為 null。
• 如果你沒有實現自己的 onSaveInstanceState()，但是 Activity 上控件的樣子可能依然能被保存并恢復。原來 Activity 類已實現了onSaveInstanceState()，在 onSaveInstanceState() 的默認實現中，會調用所有控件的相關方法，把控件們的狀態都保存下來，比如 EditText 中輸入的文字、CheckBox 是否被選中等等。然而不是所有的控件都能被保存，這取決于你是否在 layout 文件中為控件賦了一個名字(android:id)。有名的就存，無名的不管。
• 既然有現成的可用，那么我們到底還要不要自己實現 onSaveInstanceState() 方法呢？這就得看情況了，如果你自己的派生類中有變量影響到UI，或你程序的行為，當然就要把這個變量也保存了，那么就需要自己實現，否則就不需要，但大多數情況肯定需要自己實現一下下了。對了，別忘了在你的實現中調用父類的 onSaveInstanceState() 方法。

注：由于 onSaveInstanceState() 方法并不是在每次被銷毀時都會調用，所以不要在其中保存那些需要永久化的數據，執行保存那些數據的最好地方是在 onPause() 方法中。

Fragment的place方法是先刪除其他fragment再添加。

Fragment之間數據傳遞的三種方式

Fragment的setArguments(Bundle)方法

創建Fragment對象時，如果需要傳遞參數，不推薦重載帶參的構造方法。通過 使用默認的構造函數 加上 Fragment.setArguments（Bundle）來取代。

public class MyFragment extends Fragment {public static MyFragment newInstance(int someInt) {MyFragment myFragment = new MyFragment();Bundle args = new Bundle();args.putInt("someInt", someInt);myFragment.setArguments(args);return myFragment;} }

根據Android文檔說明，當一個fragment重新創建的時候，系統會再次調用 Fragment中的默認構造函數。?注意這里：是默認構造函數。

當你創建了一個帶有重要參數的Fragment的之后，一旦由于什么原因（橫豎屏切換）導致你的Fragment重新創建。你之前傳遞的參數都不見了。

使用系統推薦的 Fragment.setArguments（Bundle）來傳遞參數。就可以有效的避免這一個問題，當你的Fragment銷毀的時候，其中的Bundle會保存下來，當要重新創建的時候會檢查Bundle是否為null，如果不為null，就會使用bundle作為參數來重新創建fragment.

疑問：當fragment重建的時候，怎么獲取之前的參數呢？?

可以重寫 fragment的onCreate()方法。

getArguments().getInt("someInt", 0);

onNewIntent()方法

只對SingleTop(且位于棧頂)，SingleTask和SingleInstance(且已經在任務棧中存在實例)的情況下，再次啟動它們時才會調用。

SingleTop：

如果ActivityA在棧頂,且現在要再啟動ActivityA，這時會調用onNewIntent()方法 ，生命周期順序為：

onCreate--->onStart--->onResume---onPause--->onNewIntent--->onResume

當ActivityA的LaunchMode為SingleInstance,SingleTask：

如果ActivityA已經在任務棧中，再次啟動ActivityA，那么此時會調用onNewIntent()方法，生命周期調用順序為：

Pause--->B跳轉回A--->onNewIntent--->onRestart--->onStart--->onResume

protected void onNewIntent(Intent intent) {super.onNewIntent(intent);setIntent(intent);//must store the new intent unless getIntent() will return the old one }

activity退出方式

RS優雅式

什么是RS式呢？即Receiver+singleTask 。我們知道Activity有四種加載模式，而singleTask就是其中的一種，使用這個模式之后，當startActivity時，它先會在當前棧中查詢是否存在Activity的實例，如果存在，則將其至于棧頂，并將其之上的所有Activity移除棧。我們打開一個app，在主頁進行N次的跳轉，期間會產生數量不定的Activity，有的被銷毀，有的駐留在棧中，但是棧底永遠是我們的HomeActivity。這樣就讓問題變得簡單很多了。我們只需兩步操作即可優雅的實現app的退出。

1、在HomeActivity注冊一個退出廣播，只需要在HomeActivity一個頁面注冊即可。?
2、設置HomeActivity的啟動模式為singleTask。?
當我們需要退出的時候只需要startActivity(this,HomeActivity,class)， 再發送一個退出廣播。上面代碼首先會把棧中HomeActivity之上的所有Activity移除出棧，然后接到廣播finish自己。一切OK ! 沒有彈框，不用考慮機型Rom適配。不會有內存問題。

SingleTask改版式

注冊廣播略顯麻煩

設置MainActivity的加載模式為singleTask?

重寫MainActivity中的onNewIntent方法?

需要退出時在Intent中添加退出的tag?

第一步設置MainActivity的加載模式為singleTask

?android:launchMode="singleTask"

第二步重寫onNewIntent()方法

private static final String TAG_EXIT = "exit";@Override protected void onNewIntent(Intent intent) {super.onNewIntent(intent);if (intent != null) {boolean isExit = intent.getBooleanExtra(TAG_EXIT, false);if (isExit) {this.finish();}} }

第三步 退出

Intent intent = new Intent(this,MainActivity.class);intent.putExtra(MainActivity.TAG_EXIT, true);startActivity(intent);

懶人式

這種方式更加簡單，只需要如下兩步操作

將MainActivity設置為singleTask?

將退出出口放置在MainActivity?

雙擊兩次返回鍵退出應用，就是基于這樣的方式來實現的，這里在貼一下如何處理連續兩次點擊退出的源碼

private long firstTime=0;@Overridepublic boolean onKeyDown(int keyCode, KeyEvent event) {if (keyCode == KeyEvent.KEYCODE_BACK) {if (System.currentTimeMillis()-firstTime>2000){Toast.makeText(MainActivity.this,"再按一次退出程序",Toast.LENGTH_SHORT).show();firstTime=System.currentTimeMillis();}else{finish();System.exit(0);}return true;}return super.onKeyDown(keyCode, event);}

android:screenOrientation屬性：

• unspecified——默認值，由系統選擇顯示方向，在不同的設備可能會有所不同。
• landscape——橫向
• portrait——縱向
• user——用戶當前的首選方向
• behind——與在活動堆棧下的活動相同方向
• sensor——根據物理方向傳感器確定方向，取決于用戶手持的方向，當用戶轉動設備，他能隨意改變。
• nosensor——不經物理方向傳感器確定方向，該傳感器被忽略，所以當用戶轉動設備，顯示不會跟隨改變，除了這個卻別，系統選擇相同的政策取向對于“未指定”設置，系統根據“未指定”（unspecified）設定選擇相同顯示方向。

從 Android 3.2 (API級別 13)以后

不設置Activity的android:configChanges時，或 設置Activity的android:configChanges="orientation"時，或設置Activity的android:configChanges="orientation|keyboardHidden"時，切屏會重新調用各個生命周期，切橫屏時會執行一次，切豎屏時會執行一次方法。

配置 android:configChanges="orientation|screenSize"，才不會銷毀 activity，且只調用 onConfigurationChanged方法。

?

RecyclerView嵌套

?

圖片加載庫對比

Picasso：120K

Glide：475K

Fresco：3.4M

Android-Universal-Image-Loader：162K

圖片函數庫的選擇需要根據APP的具體情況而定，對于嚴重依賴圖片緩存的APP，例如壁紙類，圖片社交類APP來說，可以選擇最專業的Fresco。對于一般的APP，選擇Fresco會顯得比較重，畢竟Fresco3.4M的體量擺在這。根據APP對圖片的顯示和緩存的需求從低到高，我們可以對以上函數庫做一個排序。

Picasso < Android-Universal-Image-Loader < Glide < Fresco

Picasso所能實現的功能，Glide都能做，無非是所需的設置不同。但是Picasso體積比起Glide小太多如果項目中網絡請求本身用的就是okhttp或者retrofit(本質還是okhttp)，那么建議用Picasso，體積會小很多(Square全家桶的干活)。Glide的好處是大型的圖片流，比如gif、Video，如果你們是做美拍、愛拍這種視頻類應用，建議使用。

ANR（Application Not Responding）：

應用程序無響應：在一定的時間內沒有做完相應的處理。

應用程序的響應性是由Activity Manager和WindowManager系統服務監視的 。

響應輸入input的事件時間超過5S，broadcastReceiver超過10S，前臺service處理超過20S，后臺service超過200S

判斷分析：發生ANR后，可以結合Logcat日志和位于收集內部存儲的/data/anr/trace.txt文件進行分析和定位。

線程中start()和run()的區別

start()：啟動相應的線程，讓一個線程進入就緒隊列等待分配cpu，分到cpu后才調用實現的run()方法。

run()：線程體，包含了線程要執行的內容。直接調用run只是一個普通的函數調用，并沒有新建線程的作用。

普通內部類如何訪問外部類：

編譯器自動為內部類生成一個帶參構造方法， 參數只有一個，類型是外部類。

編譯器自動為內部類添加一個成員變量，通過第一步的構造函數賦值，?這個成員變量就是指向外部類對象的引用；

內部類通過該引用訪問外部類屬性。

Android 查看內存使用情況

ADB命令

查看應用程序的命令：adb shell procrank

查看單個應用程序內存占用量的命令：adb shell dumpsys meminfo $包名 或者 $進程號

PID? ? ?Vss? ? ? ? Rss? ? ? ??Pss? ? ? ? Uss? ? ? ? ?cmdline

190 ?79560K ?74736K ?49624K ?43604K? system_server

• VSS?- Virtual Set Size 虛擬耗用內存（包含共享庫占用的內存）
• RSS?- Resident Set Size 實際使用物理內存（包含共享庫占用的內存）
• PSS?- Proportional Set Size 實際使用的物理內存（比例分配共享庫占用的內存）
• USS?- Unique Set Size 進程獨自占用的物理內存（不包含共享庫占用的內存）

DDMS工具

sdk文件夾->tools->monitor.bat

Android為什么要設計出Bundle而不是直接使用HashMap來進行數據傳遞？

Bundle內部是由ArrayMap實現的，ArrayMap的內部實現是兩個數組，一個int數組是存儲對象數據對應下標，一個對象數組保存key和value，內部使用二分法對key進行排序，所以在添加、刪除、查找數據的時候，都會使用二分法查找，只適合于小數據量操作，如果在數據量比較大的情況下，那么它的性能將退化。

HashMap內部則是數組+鏈表結構，所以在數據量較少的時候，數組占用內存少，HashMap的Entry Array比ArrayMap占用更多的內存。因為使用Bundle的場景大多數為小數據量，我沒見過在兩個Activity之間傳遞10個以上數據的場景，所以相比之下，在這種情況下使用ArrayMap保存數據，在操作速度和內存占用上都具有優勢，因此使用Bundle來傳遞數據，可以保證更快的速度和更少的內存占用。

另外一個原因，則是在Android中如果使用Intent來攜帶數據的話，需要數據是基本類型或者是可序列化類型，HashMap使用Serializable進行序列化，而Bundle則是使用Parcelable進行序列化。而在Android平臺中，更推薦使用Parcelable實現序列化，雖然寫法復雜，但是開銷更小，所以為了更加快速的進行數據的序列化和反序列化，系統封裝了Bundle類，方便我們進行數據的傳輸。

ScrollView嵌套ListView

只顯示一個item：

動態計算ListView高度并賦值。

重寫onMeasure()。

滑動沖突：

listVIew中調用getParent().requestDisallowInterceptTouchEvent(true);禁止父View攔截事件。

@Overridepublic boolean dispatchTouchEvent(MotionEvent ev) {switch (ev.getAction()){case MotionEvent.ACTION_DOWN:getParent().requestDisallowInterceptTouchEvent(true);break;case MotionEvent.ACTION_MOVE:boolean a = !canScrollVertically(-1);boolean b = ev.getY()-firstY>0;boolean c = !canScrollVertically(1);boolean d = ev.getY()-firstY<0;if ( (b&&a)|| (c&& d))getParent().requestDisallowInterceptTouchEvent(false);break;} 三級緩存

網絡緩存，不優先加載，速度慢，浪費流量。

本地緩存，次優先加載，速度快。

內存緩存，優先加載，速度最快。

首次加載Android App時，肯定要通過網絡交互來獲取圖片，之后我們可以將圖片保存至本地SD卡和內存中，之后運行APP時，優先訪問內存中的圖片緩存，若內存中沒有，則加載本地SD卡中圖片，最后選擇訪問網絡

Context

Context類本身是一個純abstract類，它有兩個具體的實現子類：ContextImpl和ContextWrapper。

ContextWrapper類，如其名所言，這只是一個包裝而已，ContextWrapper構造函數中必須包含一個真正的Context引用，同時ContextWrapper中提供了attachBaseContext（）用于給ContextWrapper對象中指定真正的Context對象，調用ContextWrapper的方法都會被轉向其所包含的真正的Context對象。ContextThemeWrapper類，如其名所言，其內部包含了與主題（Theme）相關的接口，這里所說的主題就是指在AndroidManifest.xml中通過android：theme為Application元素或者Activity元素指定的主題。當然，只有Activity才需要主題，Service是不需要主題的，因為Service是沒有界面的后臺場景，所以Service直接繼承于ContextWrapper，Application同理。而ContextImpl類則真正實現了Context中的所以函數，應用程序中所調用的各種Context類的方法，其實現均來自于該類。一句話總結：Context的兩個子類分工明確，其中ContextImpl是Context的具體實現類，ContextWrapper是Context的包裝類。Activity，Application，Service雖都繼承自ContextWrapper（Activity繼承自ContextWrapper的子類ContextThemeWrapper），但它們初始化的過程中都會創建ContextImpl對象，由ContextImpl實現Context中的方法。

Context數量=Activity數量+Service數量+1

WebView 優化

• 另開WebView進程

<activityandroid:name=".activity.WebActivity"//設置android:process屬性來使其運行在指定的進程中android:process=":webActivity"><intent-filter><action android:name="com.activity.Webactivity"/><category android:name="android.intent.category.DEFAULT"/></intent-filter> </activity>

• 使用WebView內置緩存

webSettings.setCacheMode(WebSettings.LOAD_DEFAULT); webSettings.setDatabaseEnabled(true); webSettings.setDomStorageEnabled(true); webSettings.setAppCacheEnabled(true);

• 資源文件預置在 app 中
• 實現WebView復用
• 實現請求攔截，如果存在緩存資源則攔截請求返回資源
• 圖片資源懶加載，先加載其他資源

//在 WebView 加載頁面之前先設置 webView.getSettings().setBlockNetworkImage(true); //將圖片下載阻塞 //在瀏覽器 OnPageFinished事件中設置 webView.getSettings().setBlockNetworkImage(false);

• 使用VasSonic：
  • 提供預加載接口，預加載 html 內容至內存
  • 僅提升 html 文件加載，js、css、圖片等資源走正常瀏覽器流程
  • 預加載不支持重定向
• 后臺 Service 預加載 WebView

?

?

?

?

?

?

總結

以上是生活随笔為你收集整理的Java、Android—零碎难记笔试考点(持续更新)的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。