面向?qū)ο笈c面向過程：

面向過程就是分析出解決問題所需要的步驟，然后用函數(shù)把這些步驟一步一步實現(xiàn)，使用的時候一個一個依次調(diào)用就可以了。
面向?qū)ο笫前褬?gòu)成問題事務(wù)分解成各個對象，建立對象的目的不是為了完成一個步驟，而是為了描敘某個事物在整個解決問題的步驟中的行為。

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

面向?qū)ο?特征：封裝、繼承、多態(tài)性。

? ? 作用域? ? ? 當(dāng)前類?同一package? 子孫類 其他package

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

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

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

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

Java與c、c++編碼到運行的區(qū)別：

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

c、c++：直接編譯成可執(zhí)行文件，無法跨平臺，不同的操作系統(tǒng)的標(biāo)準(zhǔn)不一樣。

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

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

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

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

從低位類型到高位類型自動轉(zhuǎn)換，從高位類型到低位類型需要強制類型轉(zhuǎn)換：

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

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

基本數(shù)據(jù)類型占字節(jié)及位數(shù)：

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

整型：

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

浮點型：

• float：4個字節(jié) 32 位
• double ：8個字節(jié) 64位

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

char類型：

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

Boolean 類型

• boolean: true or false

算術(shù)運算規(guī)則

基本就是先轉(zhuǎn)換為高位數(shù)據(jù)類型，再參加運算，結(jié)果也是最高位的數(shù)據(jù)類型；

byte short char運算會轉(zhuǎn)換為Int；

String類是final類

“對String對象的任何改變都不影響到原對象，相關(guān)的任何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);} }

當(dāng)對String類對象進行substring()，replace()等，應(yīng)該賦值給新的String對象，因為a還是原來的內(nèi)容。

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

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"被存儲在運行時常量池（當(dāng)然只保存了一份）。通過這種方式來將String對象跟引用綁定的話，JVM執(zhí)行引擎會先在運行時常量池查找是否存在相同的字面常量，如果存在，則直接將引用指向已經(jīng)存在的字面常量；否則在運行時常量池開辟一個空間來存儲該字面常量，并將引用指向該字面常量。通過new關(guān)鍵字來生成對象是在堆區(qū)進行的，而在堆區(qū)進行對象生成的過程是不會去檢測該對象是否已經(jīng)存在的。因此通過new來創(chuàng)建對象，創(chuàng)建出的一定是不同的對象，即使字符串的內(nèi)容是相同的。

"=="和eqals區(qū)別：

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

StringBuilder和StringBuffer類區(qū)別：

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

序列化和反序列化

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

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

transient關(guān)鍵字

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

volatile關(guān)鍵字

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

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

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

為了保證數(shù)據(jù)準(zhǔn)確性一般使用Synchronize、lock或者AtomicInteger。AtomicInteger采用CAS保證線程安全。

static關(guān)鍵字

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

類初始化的順序：

父類靜態(tài)變量->父類靜態(tài)代碼塊->子類靜態(tài)變量->子類靜態(tài)代碼塊->父類普通變量->父類普通代碼塊->父類構(gòu)造函數(shù)->子類普通變量->子類普通代碼塊->子類構(gòu)造函數(shù)

假設(shè)類A有靜態(tài)內(nèi)部類B和非靜態(tài)內(nèi)部類C，創(chuàng)建B和C的區(qū)別為：
A a=new A();
A.B b=new A.B();
A.C c=a.new C();

final關(guān)鍵字

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

final、finally、finalize的區(qū)別與用法

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

try - with - resource

jdk1.7引入的try with resources語法糖式寫法。try-with-resources 語句確保了每個資源在語句結(jié)束時關(guān)閉。所有實現(xiàn)了 java.lang.AutoCloseable 接口（其中，它包括實現(xiàn)了 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");} }執(zhí)行輸出如下： do something resource is closed

在 try 語句中，可以創(chuàng)建多個資源，中間用；隔開，越是最后使用的資源，越是最早被關(guān)閉。

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

抽象類與接口區(qū)別：

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

匿名類又稱匿名內(nèi)部類：

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

重載（Overload）和重寫（Override）的區(qū)別？

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

重寫：

發(fā)生在父類與子類之間

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

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

重寫方法一定不能拋出新的檢查異常或者比被重寫方法申明更加寬泛的檢查型異常

多態(tài)存在的三個條件

靜態(tài)多態(tài)：重載

動態(tài)多態(tài)：

• 有繼承關(guān)系　　
• 子類重寫父類方法　　
• 父類引用指向子類對象

多態(tài)的實現(xiàn)

方法表：在JVM執(zhí)行Java字節(jié)碼時，類型信息被存放在方法區(qū)中，通常為了優(yōu)化對象調(diào)用方法的速度，方法區(qū)的類型信息中增加一個指針，該指針指向一張記錄該類方法入口的表（稱為方法表），表中的每一項都是指向相應(yīng)方法的指針。

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

多態(tài)的實例方法調(diào)用實際上有兩種指令：

• invokevirtual指令用于調(diào)用聲明為類的方法；
• invokeinterface指令用于調(diào)用聲明為接口的方法。

靜態(tài)方法是由虛擬機指令invokestatic調(diào)用的，私有方法和構(gòu)造函數(shù)則是由invokespecial指令調(diào)用，只有被invokevirtual和invokeinterface指令調(diào)用的方法才會在方法表中出現(xiàn)。

invokevirtual ：

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

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

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

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

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

invokeinterface：

因為?Java?類是可以同時實現(xiàn)多個接口的，而當(dāng)用接口引用調(diào)用某個方法的時候，情況就有所不同了。

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

動態(tài)編譯與靜態(tài)編譯

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

泛型的意義在于

適用于多種數(shù)據(jù)類型執(zhí)行相同的代碼（代碼復(fù)用）

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

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反射機制是在運行狀態(tài)中，對于任意一個類，都能夠知道這個類的所有屬性和方法；對于任意一個對象，都能夠調(diào)用它的任意一個方法和屬性；這種動態(tài)獲取的信息以及動態(tài)調(diào)用對象的方法的功能稱為Java語言的反射機制。

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

反射就是在運行時才知道要操作的類是什么，并且可以在運行時獲取類的完整構(gòu)造，并調(diào)用對應(yīng)的方法。

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

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

new與反射區(qū)別

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

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

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

反射提供了一種更加靈活的方式創(chuàng)建對象，得到對象的信息。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; };//單鏈表逆置實現(xiàn) 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; }

排序算法：

桶排序：

• 平均時間復(fù)雜度：O(n + k)
• 最佳時間復(fù)雜度：O(n + k)
• 最差時間復(fù)雜度：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]);}//對桶內(nè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);}

插入排序：

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

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

希爾排序：

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

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

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

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

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

時間復(fù)雜度為 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;} }

遞歸通常用棧來實現(xiàn)。

守護進程

在linux系統(tǒng)中，我們會發(fā)現(xiàn)在系統(tǒng)啟動的時候有很多的進程就已經(jīng)開始跑了，也稱為服務(wù)，這也是我們所說的守護進程。

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

異常：

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

Error

Error及其子類用來描述Java運行系統(tǒng)中的內(nèi)部錯誤以及資源耗盡的錯誤，是程序無法處理的錯誤，這類錯誤比較嚴(yán)重。這類的大多數(shù)錯誤與代碼編寫者執(zhí)行的操作無關(guān)，如，運行代碼時，JVM（Java虛擬機）出現(xiàn)的問題，例如，Java虛擬機運行錯誤（Virtual MachineError），當(dāng) JVM 不再有繼續(xù)執(zhí)行操作所需的內(nèi)存資源時，將出現(xiàn) OutOfMemoryError。

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

異常與錯誤的區(qū)別是：異常可以通過程序自身捕捉處理，而錯誤是程序自身無法處理的。

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

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

ThreadLocal

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

ThreadLocal的接口方法

//設(shè)置當(dāng)前線程的線程局部變量的值。 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() 該方法返回當(dāng)前線程所對應(yīng)的線程局部變量。public void remove() 將當(dāng)前線程局部變量的值刪除，目的是為了減少內(nèi)存的占用，該方法是JDK 5.0新增的方法。 需要指出的是，當(dāng)線程結(jié)束后，對應(yīng)該線程的局部變量將自動被垃圾回收， 所以顯式調(diào)用該方法清除線程的局部變量并不是必須的操作，但它可以加快內(nèi)存回收的速度。

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

應(yīng)用：

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

線程間數(shù)據(jù)隔離

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

數(shù)據(jù)庫連接，Session會話管理。

URI與URL

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

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

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

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

File實現(xiàn)了?Serializable，可以用Intent傳遞。

四種啟動模式：

Standard? ：普通activity

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

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

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

Activity A跳轉(zhuǎn)到B：

A：onPause()

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

A:? onStop()

onSaveInstanceState方法

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

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

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

Fragment之間數(shù)據(jù)傳遞的三種方式

Fragment的setArguments(Bundle)方法

創(chuàng)建Fragment對象時，如果需要傳遞參數(shù)，不推薦重載帶參的構(gòu)造方法。通過 使用默認(rèn)的構(gòu)造函數(shù) 加上 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;} }

根據(jù)Android文檔說明，當(dāng)一個fragment重新創(chuàng)建的時候，系統(tǒng)會再次調(diào)用 Fragment中的默認(rèn)構(gòu)造函數(shù)。?注意這里：是默認(rèn)構(gòu)造函數(shù)。

當(dāng)你創(chuàng)建了一個帶有重要參數(shù)的Fragment的之后，一旦由于什么原因（橫豎屏切換）導(dǎo)致你的Fragment重新創(chuàng)建。你之前傳遞的參數(shù)都不見了。

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

疑問：當(dāng)fragment重建的時候，怎么獲取之前的參數(shù)呢？?

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

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

onNewIntent()方法

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

SingleTop：

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

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

當(dāng)ActivityA的LaunchMode為SingleInstance,SingleTask：

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

Pause--->B跳轉(zhuǎn)回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優(yōu)雅式

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

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

SingleTask改版式

注冊廣播略顯麻煩

設(shè)置MainActivity的加載模式為singleTask?

重寫MainActivity中的onNewIntent方法?

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

第一步設(shè)置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設(shè)置為singleTask?

將退出出口放置在MainActivity?

雙擊兩次返回鍵退出應(yīng)用，就是基于這樣的方式來實現(xiàn)的，這里在貼一下如何處理連續(xù)兩次點擊退出的源碼

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——默認(rèn)值，由系統(tǒng)選擇顯示方向，在不同的設(shè)備可能會有所不同。
• landscape——橫向
• portrait——縱向
• user——用戶當(dāng)前的首選方向
• behind——與在活動堆棧下的活動相同方向
• sensor——根據(jù)物理方向傳感器確定方向，取決于用戶手持的方向，當(dāng)用戶轉(zhuǎn)動設(shè)備，他能隨意改變。
• nosensor——不經(jīng)物理方向傳感器確定方向，該傳感器被忽略，所以當(dāng)用戶轉(zhuǎn)動設(shè)備，顯示不會跟隨改變，除了這個卻別，系統(tǒng)選擇相同的政策取向?qū)τ凇拔粗付ā痹O(shè)置，系統(tǒng)根據(jù)“未指定”（unspecified）設(shè)定選擇相同顯示方向。

從 Android 3.2 (API級別 13)以后

不設(shè)置Activity的android:configChanges時，或 設(shè)置Activity的android:configChanges="orientation"時，或設(shè)置Activity的android:configChanges="orientation|keyboardHidden"時，切屏?xí)匦抡{(diào)用各個生命周期，切橫屏?xí)r會執(zhí)行一次，切豎屏?xí)r會執(zhí)行一次方法。

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

?

RecyclerView嵌套

?

圖片加載庫對比

Picasso：120K

Glide：475K

Fresco：3.4M

Android-Universal-Image-Loader：162K

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

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

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

ANR（Application Not Responding）：

應(yīng)用程序無響應(yīng)：在一定的時間內(nèi)沒有做完相應(yīng)的處理。

應(yīng)用程序的響應(yīng)性是由Activity Manager和WindowManager系統(tǒng)服務(wù)監(jiān)視的 。

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

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

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

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

run()：線程體，包含了線程要執(zhí)行的內(nèi)容。直接調(diào)用run只是一個普通的函數(shù)調(diào)用，并沒有新建線程的作用。

普通內(nèi)部類如何訪問外部類：

編譯器自動為內(nèi)部類生成一個帶參構(gòu)造方法， 參數(shù)只有一個，類型是外部類。

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

內(nèi)部類通過該引用訪問外部類屬性。

Android 查看內(nèi)存使用情況

ADB命令

查看應(yīng)用程序的命令：adb shell procrank

查看單個應(yīng)用程序內(nèi)存占用量的命令：adb shell dumpsys meminfo $包名 或者 $進程號

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

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

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

DDMS工具

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

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

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

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

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

ScrollView嵌套ListView

只顯示一個item：

動態(tài)計算ListView高度并賦值。

重寫onMeasure()。

滑動沖突：

listVIew中調(diào)用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;} 三級緩存

網(wǎng)絡(luò)緩存，不優(yōu)先加載，速度慢，浪費流量。

本地緩存，次優(yōu)先加載，速度快。

內(nèi)存緩存，優(yōu)先加載，速度最快。

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

Context

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

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

Context數(shù)量=Activity數(shù)量+Service數(shù)量+1

WebView 優(yōu)化

• 另開WebView進程

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

• 使用WebView內(nèi)置緩存

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

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

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

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

?

?

?

?

?

?

總結(jié)

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

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。