以下是自己總結的一些Java常見的基礎知識題，答案僅供參考，如有異議請指出。一直保持更新狀態。

1.什麼是Java虛擬機器？為什麼Java被稱作是“平臺無關的程式語言”？
Java虛擬機器是一個可以執行Java位元組碼的虛擬機器程序。Java原始檔被編譯成能被Java虛擬機器執行的位元組碼檔案。

2.“static”關鍵字是什麼意思？Java中是否可以覆蓋(override)一個private或者是static的方法？
“static”關鍵字表明一個成員變數或者是成員方法可以在沒有所屬的類的例項變數的情況下被訪問。
Java中static方法不能被覆蓋，因為方法覆蓋是基於執行時動態繫結的，而static方法是編譯時靜態繫結的。static方法跟類的任何例項都不相關，所以概念上不適用。

3.是否可以在static環境中訪問非static變數？
static變數在Java中是屬於類的，它在所有的例項中的值是一樣的。當類被Java虛擬機器載入的時候，會對static變數進行初始化。如果你的程式碼嘗試不用例項來訪問非static的變數，編譯器會報錯，因為這些變數還沒有被創建出來，還沒有跟任何例項關聯上。

4.Java支援的資料型別有哪些？什麼是自動拆裝箱？
Java語言支援的8中基本資料型別是：
• byte
• short
• int
• long
• float
• double
• boolean
• char
自動裝箱是Java編譯器在基本資料型別和對應的物件包裝型別之間做的一個轉化。比如：把int轉化成Integer，double轉化成double，等等。反之就是自動拆箱。

5.Overload和Override的區別。Overloaded的方法是否可以改變返回值的型別?
方法的重寫Overriding和過載Overloading是Java多型性的不同表現。重寫Overriding是父類與子類之間多型性的一種表現，過載O verloading是一個類中多型性的一種表現。如果在子類中定義某方法與其父類有相同的名稱和引數，我們說該方法被重寫(Overriding)。子類的物件使用這個方法時，將呼叫子類中的定義，對它而言，父類中的定義如同被”遮蔽”了。如果在一個類中定義了多個同名的方法，它們或有不同的引數個數或有不同的引數型別，則稱為方法的過載(Overloading)。Overloaded的方法是可以改變返回值的型別。

6.Java支援多繼承麼？
不支援，Java不支援多繼承。每個類都只能繼承一個類，但是可以實現多個介面。

7.介面和抽象類的區別是什麼？
Java提供和支援建立抽象類和介面。它們的實現有共同點，不同點在於：
• 介面中所有的方法隱含的都是抽象的。而抽象類則可以同時包含抽象和非抽象的方法。
• 類可以實現很多個介面，但是隻能繼承一個抽象類
• 類如果要實現一個介面，它必須要實現介面宣告的所有方法。但是，類可以不實現抽象類宣告的所有方法，當然，在這種情況下，類也必須得宣告成是抽象的。
• 抽象類可以在不提供介面方法實現的情況下實現介面。
• Java介面中宣告的變數預設都是final的。抽象類可以包含非final的變數。
• Java介面中的成員函式預設是public的。抽象類的成員函式可以是private，protected或者是public。
• 介面是絕對抽象的，不可以被例項化。抽象類也不可以被例項化，但是，如果它包含main方法的話是可以被呼叫的。
也可以參考JDK8中抽象類和介面的區別

8.什麼是值傳遞和引用傳遞？
物件被值傳遞，意味著傳遞了物件的一個副本。因此，就算是改變了物件副本，也不會影響源物件的值。
物件被引用傳遞，意味著傳遞的並不是實際的物件，而是物件的引用。因此，外部對引用物件所做的改變會反映到所有的物件上。

9.建立執行緒有幾種不同的方式？你喜歡哪一種？為什麼？
有三種方式可以用來建立執行緒：
• 繼承Thread類
• 實現Runnable介面
• 應用程式可以使用Executor框架來建立執行緒池
實現Runnable介面這種方式更受歡迎，因為這不需要繼承Thread類。在應用設計中已經繼承了別的物件的情況下，這需要多繼承（而Java不支援多繼承），只能實現介面。同時，執行緒池也是非常高效的，很容易實現和使用。

10.同步方法和同步程式碼塊的區別是什麼？
在Java語言中，每一個物件有一把鎖。執行緒可以使用synchronized關鍵字來獲取物件上的鎖。synchronized關鍵字可應用在方法級別(粗粒度鎖：這裡的鎖物件可以是This)或者是程式碼塊級別(細粒度鎖：這裡的鎖物件就是任意物件)。

11.什麼是死鎖(deadlock)？
兩個程序都在等待對方執行完畢才能繼續往下執行的時候就發生了死鎖。結果就是兩個程序都陷入了無限的等待中。
程式碼表示：

程式碼描述：

public class DieLockDemo {
public static void main(String[] args) {
DieLock dl1 = new DieLock(true);
DieLock dl2 = new DieLock(false);

dl1.start();
dl2.start();
}
}
*...理想狀態下dl1執行緒為true從if執行先打出"if objA"然後再接著打出"if objB"之後釋放A、B的鎖物件，之後dl2執行緒執行else語句打出"else objB"，"else objA"。
非理想狀態下dl1先打出"if objA"，之後執行緒dl2執行打出"else objB"，然後1、2執行緒的鎖物件A和B都處於被鎖的狀態，兩個執行緒爭奪鎖物件發生死鎖現象。..*
public class DieLock extends Thread {
private boolean flag;
public DieLock(boolean flag) {
this.flag = flag;
}
@Override
public void run() {
if (flag) {
synchronized (MyLock.objA) {
System.out.println("if objA");
synchronized (MyLock.objB) {
System.out.println("if objB");
}
}
} else {
synchronized (MyLock.objB) {
System.out.println("else objB");
synchronized (MyLock.objA) {
System.out.println("else objA");
}
}
}
}
}

12.如何確保N個執行緒可以訪問N個資源同時又不導致死鎖？
使用多執行緒的時候，一種非常簡單的避免死鎖的方式就是：指定獲取鎖的順序，並強制執行緒按照指定的順序獲取鎖。因此，如果所有的執行緒都是以同樣的順序加鎖和釋放鎖，就不會出現死鎖了。

13.Java集合類框架的基本介面有哪些？
Java集合類提供了一套設計良好的支援對一組物件進行操作的介面和類。Java集合類裡面最基本的介面有：
• Collection：代表一組物件，每一個物件都是它的子元素。
• Set：不包含重複元素的Collection。
• List：有順序的collection，並且可以包含重複元素。
• Map：可以把鍵(key)對映到值(value)的物件，鍵不能重複。

14.什麼是迭代器(Iterator)？
Iterator介面提供了很多對集合元素進行迭代的方法。每一個集合類都包含了可以返回迭代器例項的迭代方法。迭代器可以在迭代的過程中刪除底層集合的元素。

15.Iterator和ListIterator的區別是什麼？
下面列出了他們的區別：
• Iterator可用來遍歷Set和List集合，但是ListIterator只能用來遍歷List。
• Iterator對集合只能是前向遍歷，ListIterator既可以前向也可以後向。
• ListIterator實現了Iterator介面，幷包含其他的功能，比如：增加元素，替換元素，獲取前一個和後一個元素的索引，等等。

16.Java中的HashMap的工作原理是什麼？
Java中的HashMap是以鍵值對(key-value)的形式儲存元素的。HashMap需要一個hash函式，它使用hashCode()和equals()方法來向集合/從集合新增和檢索元素。當呼叫put()方法的時候，HashMap會計算key的hash值，然後把鍵值對儲存在集合中合適的索引上。如果key已經存在了，value會被更新成新值。HashMap的一些重要的特性是它的容量(capacity)，負載因子(load factor)和擴容極限(threshold resizing)。

17.HashMap和Hashtable有什麼區別？
• HashMap和Hashtable都實現了Map介面，因此很多特性非常相似。但是，他們有以下不同點：
• HashMap允許鍵和值是null，而Hashtable不允許鍵或者值是null。
• Hashtable是同步的，而HashMap不是。因此，HashMap更適合於單執行緒環境，而Hashtable適合於多執行緒環境。
• HashMap提供了可供應用迭代的鍵的集合，因此，HashMap是快速失敗的。另一方面，Hashtable提供了對鍵的列舉(Enumeration)。
o 一般認為Hashtable是一個遺留的類。

18.陣列(Array)和列表(ArrayList)有什麼區別？什麼時候應該使用Array而不是ArrayList？
下面列出了Array和ArrayList的不同點：
• Array可以包含基本型別和物件型別，ArrayList只能包含物件型別。
• Array大小是固定的，ArrayList的大小是動態變化的。
• ArrayList提供了更多的方法和特性，比如：addAll()，removeAll()，iterator()等等。
• 對於基本型別資料，集合使用自動裝箱來減少編碼工作量。但是，當處理固定大小的基本資料型別的時候，這種方式相對比較慢。

19.ArrayList和LinkedList有什麼區別？
ArrayList和LinkedList都實現了List介面，他們有以下的不同點：
• ArrayList是基於索引的資料介面，它的底層是陣列。它可以以O(1)時間複雜度對元素進行隨機訪問。與此對應，LinkedList是以元素連結串列的形式儲存它的資料，每一個元素都和它的前一個和後一個元素連結在一起，在這種情況下，查詢某個元素的時間複雜度是O(n)。
• 相對於ArrayList，LinkedList的插入，新增，刪除操作速度更快，因為當元素被新增到集合任意位置的時候，不需要像陣列那樣重新計算大小或者是更新索引。
• LinkedList比ArrayList更佔記憶體，因為LinkedList為每一個節點儲存了兩個引用，一個指向前一個元素，一個指向下一個元素。
也可以參考ArrayList vs. LinkedList。

20.如何權衡是使用無序的陣列還是有序的陣列？
有序陣列最大的好處在於查詢的時間複雜度是O(log n)，而無序陣列是O(n)。有序陣列的缺點是插入操作的時間複雜度是O(n)，因為值大的元素需要往後移動來給新元素騰位置。相反，無序陣列的插入時間複雜度是常量O(1)。

21.HashSet和TreeSet有什麼區別？
HashSet是由一個hash表來實現的，因此，它的元素是無序的。add()，remove()，contains()方法的時間複雜度是O(1)。
另一方面，TreeSet是由一個樹形的結構來實現的，它裡面的元素是有序的。因此，add()，remove()，contains()方法的時間複雜度是O(logn)。

22.Java中垃圾回收有什麼目的？什麼時候進行垃圾回收？
垃圾回收的目的是識別並且丟棄應用不再使用的物件來釋放和重用資源。

23.如果物件的引用被置為null，垃圾收集器是否會立即釋放物件佔用的記憶體？
不會，在下一個垃圾回收週期中，這個物件將是可被回收的。

24、String是最基本的資料型別嗎?
基本資料型別包括byte、int、char、long、float、double、boolean和short。
java.lang.String類是final型別的，因此不可以繼承這個類、不能修改這個類。為了提高效率節省空間，我們應該用StringBuffer類

25、int 和 Integer 有什麼區別
Java 提供兩種不同的型別：引用型別和原始型別（或內建型別）。Int是java的原始資料型別，Integer是java為int提供的封裝類。Java為每個原始型別提供了封裝類。

26、String 和StringBuffer的區別
JAVA平臺提供了兩個類：String和StringBuffer，它們可以儲存和操作字串，即包含多個字元的字元資料。這個String類提供了數值不可改變的字串。而這個StringBuffer類提供的字串進行修改。

27、說出ArrayList,Vector, LinkedList的儲存效能和特性
ArrayList 和Vector都是使用陣列方式儲存資料，此陣列元素數大於實際儲存的資料以便增加和插入元素，它們都允許直接按序號索引元素，但是插入元素要涉及陣列元素移動等記憶體操作，所以索引資料快而插入資料慢，Vector由於使用了synchronized方法（執行緒安全），通常效能上較ArrayList差，而 Linke dList使用雙向連結串列實現儲存，按序號索引資料需要進行前向或後向遍歷，但是插入資料時只需要記錄本項的前後項即可，所以插入速度較快。

List的子類特點
        ArrayList:
            底層資料結構是陣列，查詢快，增刪慢
            執行緒不安全，效率高
        Vector:
            底層資料結構是陣列，查詢快，增刪慢
            執行緒安全，效率低
        LinkedList:
            底層資料結構是連結串列，查詢慢，增刪快
            執行緒不安全，效率高

28、Collection 和 Collections的區別
Collection是集合類的上級介面，繼承與他的介面主要有Set 和List.
Collections是針對集合類的一個幫助類，他提供一系列靜態方法實現對各種集合的搜尋、排序、執行緒安全化等操作。
集合的繼承體系：

29、&和&&的區別。
&是位運算子，表示按位與運算，&&是邏輯運算子，表示邏輯與（and）。

30、final, finally, finalize的區別。
final
用於宣告屬性，方法和類，分別表示屬性不可變，方法不可覆蓋，類不可繼承。
finally是異常處理語句結構的一部分，表示總是執行。
finalize是Object類的一個方法，在垃圾收集器執行的時候會呼叫被回收物件的此方法，可以覆蓋此方法提供垃圾收集時的其他資源回收，例如關閉檔案等。

31、sleep() 和 wait() 有什麼區別?
sleep是執行緒類（Thread）的方法，導致此執行緒暫停執行指定時間，給執行機會給其他執行緒，但是監控狀態依然保持，到時後會自動恢復。呼叫sleep不會釋放物件鎖。
wait是Object類的方法，對此物件呼叫wait方法導致本執行緒放棄物件鎖，進入等待此物件的等待鎖定池，只有針對此物件發出notify方法（或not ifyAll）後本執行緒才進入物件鎖定池準備獲得物件鎖進入執行狀態。

32、error和exception有什麼區別?
error
表示恢復不是不可能但很困難的情況下的一種嚴重問題。比如說記憶體溢位。不可能指望程式能處理這樣的情況。
exception
表示一種設計或實現問題。也就是說，它表示如果程式執行正常，從不會發生的情況。

33、同步和非同步有何異同，在什麼情況下分別使用他們？舉例說明。
如果資料將線上程間共享。例如正在寫的資料以後可能被另一個執行緒讀到，或者正在讀的資料可能已經被另一個執行緒寫過了，那麼這些資料就是共享資料，必須進行同步存取。
當應用程式在物件上呼叫了一個需要花費很長時間來執行的方法，並且不希望讓程式等待方法的返回時，就應該使用非同步程式設計，在很多情況下采用非同步途徑往往更有效率。

34、GC是什麼? 為什麼要有GC?
GC是垃圾收集的意思（Gabage Collection）,記憶體處理是程式設計人員容易出現問題的地方，忘記或者錯誤的記憶體回收會導致程式或系統的不穩定甚至崩潰，Java提供的GC功能可以自動監測物件是否超過作用域從而達到自動回收記憶體的目的，Java語言沒有提供釋放已分配記憶體的顯示操作方法。

35、short s1 = 1; s1 = s1 + 1;有什麼錯? short s1 = 1; s1 +=
1;有什麼錯?
short s1 = 1; s1 = s1 + 1;
（s1+1運算結果是int型，需要強制轉換型別）
short s1 = 1; s1 += 1;（可以正確編譯，+=內建運算子運算時可自動變換資料型別）

36、Math.round(11.5)等於多少? Math.round(-11.5)等於多少?
Math.round(11.5)==12
Math.round(-11.5)==-11
round方法返回與引數最接近的長整數，引數加1/2後求其floor.

37、String s = new String(“xyz”);建立了幾個String Object?
兩個，一個是在堆中建立的s一個是在字串常量池中建立的“xyz”。

38、介面是否可繼承介面?
抽象類是否可實現(implements)介面?
抽象類是否可繼承實體類(concrete class)?
介面可以繼承介面。抽象類可以實現(implements)介面，抽象類是否可繼承實體類，但前提是實體類必須有明確的建構函式。

39、List, Set, Map是否繼承自Collection介面?
List，Set是，Map不是

40、abstract的method是否可同時是static,是否可同時是native，是否可同時是synchronized?
都不能

41、是否可以繼承String類?
String類是final類故不可以繼承。

42、swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上?
switch（expr1）中，expr1是一個整數表示式。因此傳遞給switch 和 case 語句的引數應該是 int、 short、 char 或者byte。long,string 都不能作用於swtich(1.7版本之後switch語句支援string型別)。

43、try {}裡有一個return語句，那麼緊跟在這個try後的finally {}裡的code會不會被執行，什麼時候被執行，在return前還是後？
會執行，在return前執行（finally中程式一定會被執行，return結束後程序結束，所以肯定在之前執行）。

44、兩個物件值相同(x.equals(y) == true)，但卻可有不同的hash code，這句話對不對?
不對，有相同的hash code。（hashcode內部也是根據物件的 來做處理的）

45、當一個執行緒進入一個物件的一個synchronized方法後，其它執行緒是否可進入此物件的其它方法?
不能，一個物件的一個synchronized方法只能由一個執行緒訪問。（同步程式碼塊時物件鎖可以是任何物件，同步方法時物件鎖只能是this物件所以無法訪問其他方法）

46、程式設計題: 寫一個Singleton出來。
Singleton模式主要作用是保證在Java應用程式中，一個類Class只有一個例項存在。
一般Singleton模式通常有幾種種形式:
第一種形式:
定義一個類，它的建構函式為private的，它有一個static的private的該類變數，在類初始化時例項話，通過一個public的getInsta nce方法獲取對它的引用,繼而呼叫其中的方法。
public class Singleton {
private Singleton(){}

//在自己內部定義自己一個例項，是不是很奇怪？
//注意這是private 只供內部呼叫
private static Singleton instance = new Singleton();

//這裡提供了一個供外部訪問本class的靜態方法，可以直接訪問
public static Singleton getInstance() {
return instance;
}

}
第二種形式:
public class Singleton {
private static Singleton instance = null;
public static synchronized Singleton getInstance() {
//這個方法比上面有所改進，不用每次都進行生成物件，只是第一次

//使用時生成例項，提高了效率！
if (instance==null)
instance＝new Singleton();
return instance; }

}
其他形式:
定義一個類，它的建構函式為private的，所有方法為static的。
一般認為第一種形式要更加安全些

47、Java的介面和C++的虛類的相同和不同處。
由於Java不支援多繼承，而有可能某個類或物件要使用分別在幾個類或物件裡面的方法或屬性，現有的單繼承機制就不能滿足要求。與繼承相比，介面有更高的靈活性，因為介面中沒有任何實現程式碼。當一個類實現了介面以後，該類要實現接口裡面所有的方法和屬性，並且接口裡面的屬性在預設狀態下面都是public static,所有方法預設情況下是public.一個類可以實現多個介面。

48、Java中的異常處理機制的簡單原理和應用。
當JAVA 程式違反了JAVA的語義規則時，JAVA虛擬機器就會將發生的錯誤表示為一個異常。違反語義規則包括2種情況。一種是JAVA類庫內建的語義檢查。例如陣列下標越界,會引發IndexOutOfBoundsException;訪問null的物件時會引發NullPointerException。另一種情況就是JAVA允許程式設計師擴充套件這種語義檢查，程式設計師可以建立自己的異常，並自由選擇在何時用throw關鍵字引發異常。所有的異常都是java.lang.Thowable的子類。

49、垃圾回收的優點和原理。並考慮2種回收機制。
Java語言中一個顯著的特點就是引入了垃圾回收機制，使c++程式設計師最頭疼的記憶體管理的問題迎刃而解，它使得Java程式設計師在編寫程式的時候不再需要考慮記憶體管理。由於有個垃圾回收機制，Java中的物件不再有”作用域”的概念，只有物件的引用才有”作用域”。垃圾回收可以有效的防止記憶體洩露，有效的使用可以使用的記憶體。垃圾回收器通常是作為一個單獨的低級別的執行緒執行，不可預知的情況下對記憶體堆中已經死亡的或者長時間沒有使用的物件進行清楚和回收，程式設計師不能實時的呼叫垃圾回收器對某個物件或所有物件進行垃圾回收。回收機制有分代複製垃圾回收和標記垃圾回收，增量垃圾回收。

50、char型變數中能不能存貯一箇中文漢字?為什麼?
能夠定義成為一箇中文的，因為java中以unicode編碼，一個char佔2個位元組，所以放一箇中文是沒問題的

51、多執行緒有幾種實現方法,都是什麼?同步有幾種實現方法,都是什麼?
多執行緒有兩種實現方法，分別是繼承Thread類與實現Runnable介面
同步的實現方面有兩種，分別是同步程式碼塊和同步方法

52、執行緒的基本概念、執行緒的基本狀態以及狀態之間的關係
執行緒指在程式執行過程中，能夠執行程式程式碼的一個執行單位，每個程式至少都有一個執行緒，也就是程式本身。
Java中的執行緒有五種狀態分別是：新建、就緒、執行、阻塞、結束。

53、簡述synchronized和java.util.concurrent.locks.Lock的異同？
主要相同點：Lock能完成synchronized所實現的所有功能
主要不同點：Lock有比synchronized更精確的執行緒語義和更好的效能。
Lock是一個類，synchronized是一個關鍵字
synchronized會自動釋放鎖，而Lock一定要求程式設計師手工釋放，並且必須在finally從句中釋放。

54、JAVA語言如何進行異常處理，關鍵字：throws,throw,try,catch,finally分別代表什麼意義？在try塊中可以丟擲異常嗎？
Java 通過面向物件的方法進行異常處理，把各種不同的異常進行分類，並提供了良好的介面。在Java中，每個異常都是一個物件，它是Throwable 類或其它子類的例項。當一個方法出現異常後便丟擲一個異常物件，該物件中包含有異常資訊，呼叫這個物件的方法可以捕獲到這個異常並進行處理。Java的異常處理是通過5 個關鍵詞來實現的：try、catch、throw、throws和finally。一般情況下是用try來執行一段程式，如果出現異常，系統會丟擲（throws）一個異常，這時候你可以通過它的型別來捕捉（catch）它，或最後（finally）由預設處理器來處理。
用try來指定一塊預防所有”異常”的程式。緊跟在try程式後面，應包含一個catch子句來指定你想要捕捉的”異常”的型別。
throw語句用來明確地丟擲一個”異常”。
throws用來標明一個成員函式可能丟擲的各種”異常”。
Finally為確保一段程式碼不管發生什麼”異常”都被執行一段程式碼。
可以在一個成員函式呼叫的外面寫一個try語句，在這個成員函式內部寫另一個try語句保護其他程式碼。每當遇到一個try語句，”異常”的框架就放到堆疊上面，直到所有的try語句都完成。如果下一級的try語句沒有對某種”異常”進行處理，堆疊就會展開，直到遇到有處理這種”異常”的try語句。

55、一個”.java“原始檔中是否可以包括多個類（不是內部類）？有什麼限制？
可以。必須只有一個類名與檔名相同。

56、java中有幾種型別的流？JDK為每種型別的流提供了一些抽象類以供繼承，請說出他們分別是哪些類？
位元組流，字元流。位元組流繼承於InputStream \ OutputStream，字元流繼承於InputStreamReader \ OutputStreamWriter。在java.io包中還有許多其他的流，主要是為了提高效能和使用方便。

57、java中會存在記憶體洩漏嗎，請簡單描述。
會。如：int i,i2; return (i-i2); //when i為足夠大的正數,i2為足夠大的負數。結果會造成溢位，導致錯誤。

58、java中實現多型的機制是什麼？
方法的重寫Overriding和過載Overloading是Java多型性的不同表現。重寫Overriding是父類與子類之間多型性的一種表現，過載Overloading是一個類中多型性的一種表現。

59、垃圾回收器的基本原理是什麼？垃圾回收器可以馬上回收記憶體嗎？有什麼辦法主動通知虛擬機器進行垃圾回收？
對於GC來說，當程式設計師建立物件時，GC就開始監控這個物件的地址、大小以及使用情況。通常，GC採用有向圖的方式記錄和管理堆(heap)中的所有物件。通過這種方式確定哪些物件是”可達的”，哪些物件是”不可達的”。當GC確定一些物件為”不可達”時，GC就有責任回收這些記憶體空間。可以。程式設計師可以手動執行System.gc()，通知GC執行，但是Java語言規範並不保證GC一定會執行。

60、什麼是java序列化，如何實現java序列化？
序列化就是一種用來處理物件流的機制，所謂物件流也就是將物件的內容進行流化。可以對流化後的物件進行讀寫操作，也可將流化後的物件傳輸於網路之間。序列化是為了解決在對物件流進行讀寫操作時所引發的問題。
序列化的實現：將需要被序列化的類實現Serializable介面，該介面沒有需要實現的方法，implements Serializable只是為了標註該物件是可被序列化的，然後使用一個輸出流(如：FileOutputStream)來構造一個ObjectOutputStream(物件流)物件，接著，使用ObjectOutputStream物件的writeObject(Object obj)方法就可以將引數為obj的物件寫出(即儲存其狀態)，要恢復的話則用輸入流。

61、是否可以從一個static方法內部發出對非static方法的呼叫？
不可以,如果其中包含物件的method()；不能保證物件初始化.

62、List、Map、Set三個介面，存取元素時，各有什麼特點？
List 以特定次序來持有元素，可有重複元素。
Set 無法擁有重複元素,內部排序。
Map 儲存key-value值，value可多值。

63、使用final關鍵字修飾一個變數時，是引用不能變，還是引用的物件不能變？
使用final關鍵字修飾一個變數時，是指引用變數不能變，引用變數所指向的物件中的內容還是可以改變的。例如，對於如下語句：
final StringBuffer a=new StringBuffer(“immutable”);
執行如下語句將報告編譯期錯誤：
a=new StringBuffer(“”);
但是，執行如下語句則可以通過編譯：
a.append(” broken!”);

有人在定義方法的引數時，可能想採用如下形式來阻止方法內部修改傳進來的引數物件：
public void method(final StringBuffer param)
{
}
實際上，這是辦不到的，在該方法內部仍然可以增加如下程式碼來修改引數物件：
param.append(“a”);

65、請說出作用域public，private，protected，以及不寫時的區別
這四個作用域的可見範圍如下表所示。
說明：如果在修飾的元素上面沒有寫任何訪問修飾符，則表示friendly。

作用域 當前類 同一package 子孫類 其他package
public √ √ √ √
protected √ √ √ ×
friendly √ √ × ×
private √ × × ×

備註：只要記住了有4種訪問許可權，4個訪問範圍，然後將全選和範圍在水平和垂直方向上分別按排從小到大或從大到小的順序排列，就很容易畫出上面的圖了。

66、執行緒如何同步和通訊。
執行緒同步
什麼是執行緒同步？
當使用多個執行緒來訪問同一個資料時，非常容易出現執行緒安全問題(比如多個執行緒都在操作同一資料導致資料不一致),所以我們用同步機制來解決這些問題。

實現同步機制有兩個方法：
1。同步程式碼塊：
synchronized(同一個資料){} 同一個資料：就是N條執行緒同時訪問一個數據。

2。同步方法：
public synchronized 資料返回型別 方法名(){}
就是使用 synchronized 來修飾某個方法，則該方法稱為同步方法。對於同步方法而言，無需顯示指定同步監視器，同步方法的同步監視器是 this 也就是該物件的本身（這裡指的物件本身有點含糊，其實就是呼叫該同步方法的物件）通過使用同步方法，可非常方便的將某類變成執行緒安全的類
執行緒通訊：

為什麼要使用執行緒通訊？

當使用synchronized 來修飾某個共享資源時(分同步程式碼塊和同步方法兩種情況）,當某個執行緒獲得共享資源的鎖後就可以執行相應的程式碼段，直到該執行緒執行完該程式碼段後才釋放對該 共享資源的鎖，讓其他執行緒有機會執行對該共享資源的修改。當某個執行緒佔有某個共享資源的鎖時，如果另外一個執行緒也想獲得這把鎖執行就需要使用wait() 和notify()/notifyAll()方法來進行執行緒通訊了。

其他答案：
同學回答說synchronized方法或程式碼塊！面試官似乎不太滿意！
只有多個synchronized程式碼塊使用的是同一個監視器物件，這些synchronized程式碼塊之間才具有執行緒互斥的效果，假如a程式碼塊用obj1作為監視器物件，假如b程式碼塊用obj2作為監視器物件，那麼，兩個併發的執行緒可以同時分別進入這兩個程式碼塊中。 …這裡還可以分析一下同步的原理。
對於同步方法的分析，所用的同步監視器物件是this
接著對於靜態同步方法的分析，所用的同步監視器物件是該類的Class物件
接著對如何實現程式碼塊與方法的同步進行分析。
67、String s = “Hello”;s = s + ” world!”;這兩行程式碼執行後，原始的String物件中的內容到底變了沒有？

沒有。因為String被設計成不可變(immutable)類，所以它的所有物件都是不可變物件。在這段程式碼中，s原先指向一個String物件，內容是 “Hello”，然後我們對s進行了+操作，那麼s所指向的那個物件是否發生了改變呢？答案是沒有。這時，s不指向原來那個物件了，而指向了另一個 String物件，內容為”Hello world!”，原來那個物件還存在於記憶體之中，只是s這個引用變數不再指向它了。

68、String 和StringBuffer的區別
JAVA平臺提供了兩個類：String和StringBuffer，它們可以儲存和操作字串，即包含多個字元的字元資料。String類表示內容不可改變的字串。而StringBuffer類表示內容可以被修改的字串。當你知道字元資料要改變的時候你就可以使用StringBuffer。典型地，你可以使用StringBuffers來動態構造字元資料。另外，String實現了equals方法，new String(“abc”).equals(new String(“abc”)的結果為true,而StringBuffer沒有實現equals方法，所以，new StringBuffer(“abc”).equals(new StringBuffer(“abc”)的結果為false。

69、StringBuffer與StringBuilder的區別
StringBuffer和StringBuilder類都表示內容可以被修改的字串，StringBuilder是執行緒不安全的，執行效率高，如果一個字串變數是在方法裡面定義，這種情況只可能有一個執行緒訪問它，不存在不安全的因素了，則用StringBuilder。如果要在類裡面定義成員變數，並且這個類的例項物件會在多執行緒環境下使用，那麼最好用StringBuffer。

70、陣列有沒有length()這個方法? String有沒有length()這個方法？
陣列沒有length()這個方法，有length的屬性。String有有length()這個方法。

71、下面的程式程式碼輸出的結果是多少？

public class  smallT
{
    public static void  main(String args[])
    {
        smallT t  = new  smallT();
        int  b  =  t.get();
        System.out.println(b);
    }

    public int  get()
    {
        try
        {
            return 1 ;
        }
        finally
        {
            return 2 ;
        }
    }
}

返回的結果是2。

72、設計4個執行緒，其中兩個執行緒每次對j增加1，另外兩個執行緒對j每次減少1。寫出程式。

以下程式使用內部類實現執行緒，對j增減的時候沒有考慮順序問題。 
public class ThreadTest1 
{ 
private int j; 
public static void main(String args[]){ 
   ThreadTest1 tt=new ThreadTest1(); 
   Inc inc=tt.new Inc(); 
   Dec dec=tt.new Dec(); 
   for(int i=0;i<2;i++){ 
       Thread t=new Thread(inc); 
       t.start(); 
           t=new Thread(dec); 
       t.start(); 
       } 
   } 
private synchronized void inc(){ 
   j++; 
   System.out.println(Thread.currentThread().getName()+"-inc:"+j); 
   } 
private synchronized void dec(){ 
   j--; 
   System.out.println(Thread.currentThread().getName()+"-dec:"+j); 
   } 
class Inc implements Runnable{ 
   public void run(){ 
       for(int i=0;i<100;i++){ 
       inc(); 
       } 
   } 
} 
class Dec implements Runnable{ 
   public void run(){ 
       for(int i=0;i<100;i++){ 
       dec(); 
       } 

73、heap和stack有什麼區別。
java的記憶體分為兩類，一類是棧記憶體，一類是堆記憶體。棧記憶體是指程式進入一個方法時，會為這個方法單獨分配一塊私屬儲存空間，用於儲存這個方法內部的區域性變數，當這個方法結束時，分配給這個方法的棧會釋放，這個棧中的變數也將隨之釋放。
堆是與棧作用不同的記憶體，一般用於存放不放在當前方法棧中的那些資料，例如，使用new建立的物件都放在堆裡，所以，它不會隨方法的結束而消失。方法中的區域性變數使用final修飾後，放在堆中，而不是棧中。
74、寫一單例項類要求精簡、清晰。

懶漢模式：
public class SingletonDemo {
    private static SingletonDemo instance;
    private SingletonDemo(){

    }
    public static SingletonDemo getInstance(){
        if(instance==null){
            instance=new SingletonDemo();
        }
        return instance;
    }
}
#如上，通過提供一個靜態的物件instance，利用private許可權的構造方法和getInstance()方法來給予訪問者一個單例。

75、一列數的規則如下: 1、1、2、3、5、8、13、21、34…… 求第30位數是多少， 用遞迴演算法實現

public class Test {  

    public static void main(String[] args) {  
        System.out.println("結果是："+Test.foo(30));  
    }  

    /** 
     * 遞迴演算法實現 
     */  
    public static int foo(int i){  
        if(i<=0)  
            return 0;  
        else if(i>0 && i<=2)  
            return 1;  
        return foo(i-1) + foo(i-2);  
    }  
}  

76、

/*
    面試題：final修飾區域性變數的問題
        基本型別：基本型別的值不能發生改變。
        引用型別：引用型別的地址值不能發生改變，但是，該物件的堆記憶體的值是可以改變的。
        結果：100
             10
   --------------
             10
             100
   --------------
             10
             100
*/
class Student {
    int age = 10;
}

class FinalTest {
    public static void main(String[] args) {
        //區域性變數是基本資料型別
        int x = 10;
        x = 100;
        System.out.println(x);
        final int y = 10;
        //無法為最終變數y分配值
        //y = 100;
        System.out.println(y);
        System.out.println("--------------");

        //區域性變數是引用資料型別
        Student s = new Student();
        System.out.println(s.age);
        s.age = 100;
        System.out.println(s.age);
        System.out.println("--------------");

        final Student ss = new Student();
        System.out.println(ss.age);
        ss.age = 100;
        System.out.println(ss.age);

        //重新分配記憶體空間
        //無法為最終變數ss分配值
        ss = new Student();
    }
}

77、多型中成員訪問的特點

/*
    多型：同一個物件(事物)，在不同時刻體現出來的不同狀態。
    舉例：
        貓是貓，貓是動物。
        水(液體，固體，氣態)。

    多型的前提：
        A:要有繼承關係。
        B:要有方法重寫。
            其實沒有也是可以的，但是如果沒有這個就沒有意義。
                動物 d = new 貓();//讀的時候從右往左讀（也可以這樣理解貓是new出來的物件，
                而左邊是一個類。所以就相當於判斷一個物件是不是這個類的例項）貓是貓，貓是動物。
                d.show();
                動物 d = new 狗();
                d.show();
        C:要有父類引用指向子類物件。
            父 f =  new 子();

    用程式碼體現一下多型。

    多型中的成員訪問特點：
        A:成員變數
            編譯看左邊，執行看左邊。
        B:構造方法
            建立子類物件的時候，訪問父類的構造方法，對父類的資料進行初始化。
        C:成員方法
            編譯看左邊，執行看右邊。
        D:靜態方法
            編譯看左邊，執行看左邊。
            (靜態和類相關，算不上重寫，所以，訪問還是左邊的)

        由於成員方法存在方法重寫，所以它執行看右邊。
*/
class Fu {
    public int num = 100;

    public void show() {
        System.out.println("show Fu");
    }

    public static void function() {
        System.out.println("function Fu");
    }
}

class Zi extends Fu {
    public int num = 1000;
    public int num2 = 200;

    public void show() {
        System.out.println("show Zi");
    }

    public void method() {
        System.out.println("method zi");
    }

    public static void function() {
        System.out.println("function Zi");
    }
}

class DuoTaiDemo {
    public static void main(String[] args) {
        //要有父類引用指向子類物件。
        //父 f =  new 子();
        Fu f = new Zi();
        System.out.println(f.num);
        //找不到符號
        //System.out.println(f.num2);

        f.show();
        //找不到符號
        //f.method();
        f.function();
    }
}