1.Java 語言的優點

面向對象,平臺無關,內存管理,安全性,多線程,Java 是解釋型的

2.Java 和 C++的區別

1. 多重繼承(java接口多重,類不支持,C++支持)
2. 自動內存管理
3. 預處理功能
4. goto語句(java不支持)
5. 引用與指針。在Java中不可能直接操作對象本身，所有的對象都由一個引用指向，必須通過這個引用才能訪問對象本身，包括獲取成員變量的值，改變對象的成員變量，調用對象的方法等。而在C++中存在引用，對象和指針三個東西，這三個東西都可以訪問對象。其實，Java中的引用和C++中的指針在概念上是相似的，他們都是存放的對象在內存中的地址值，只是在Java中，引用喪失了部分靈活性，比如Java中的引用不能像C++中的指針那樣進行加減運算
   。

3.值傳遞和引用傳遞

變量被值傳遞，意味著傳遞了變量的一個副本。因此，就算是改變了變量副本，也不會影響源對象的值。 對象被引用傳遞，意味著傳遞的並不是實際的對象，而是對象的引用。因此，外部對引用對象所做的改變會反映到所有的對象上。 java本質上還是值傳遞，如方法調用的時候傳入一個對象引用進去，在方法棧中會構建一個副本和該引用變量值相同指向同一個地址。如果改變引用的值不會對改變傳入的引用的值。

4.靜態變量和實例變量的區別

在語法定義上的區別：靜態變量前要加 static 關鍵字，而實例變量前則不加。 在程序運行時的區別：實例變量屬於某個對象的屬性，必須創建了實例對象，其中的實例變量才會被分配空間，才能使用這個實例變量。靜態變量不屬於某個實例對象，而是屬於類，所以也稱為類變量，只要程序加載了類的字節碼，不用創建任何實例對象，靜態變量就會被分配空間，靜態變量就可以被使用了。總之，實例變量必須創建對象後才可以通過這個對象來使用，靜態變量則可以直接使用類名來引用。

5.JDK 包.

JDK 常用的 package java.lang：這個是系統的基礎類，比如 String 等都是這裏面的，這個 package 是唯一一個可以不用 import 就可以使用的 Package java.io: 這裏面是所有輸入輸出有關的類，比如文件操作等 java.net: 這裏面是與網絡有關的類，比如 URL,URLConnection 等。 java.util: 這個是系統輔助類，特別是集合類 Collection,List,Map 等。 java.sql: 這個是數據庫操作的類，Connection, Statememt，ResultSet 等

6.JDK, JRE 和 JVM 的區別

JDK,JRE和JVM 是 Java 編程語言的核心概念。盡管它們看起來差不多，作為程序員我們也不怎麽關心這些概念，但是它們是不同的針對特定目的的產品。這是一道常見的 Java 面試題，而本文則會一一解釋這些概念並給出它們之間的區別。 1）Java 開發工具包 (JDK) Java 開發工具包是 Java 環境的核心組件，並提供編譯、調試和運行一個 Java 程序所需的所有工具，可執行文件和二進制文件。包括java基礎jar包、虛擬機、javac等可執行文件等。JDK 是一個平臺特定的軟件，有針對 Windows，Mac 和 Unix 系統的不同的安裝包。可以說 JDK 是 JRE 的超集，它包含了 JRE 的 Java 編譯器，調試器和核心類。 2）Java 虛擬機(JVM) JVM 是 Java 編程語言的核心。當我們運行一個程序時，JVM 負責將字節碼轉換為特定機器代碼。JVM 也是平臺特定的，並提供核心的 Java 方法，例如內存管理、垃圾回收和安全機制等。JVM 是可定制化的，我們可以通過 Java 選項(java options)定制它，比如配置 JVM 內存的上下界。JVM 之所以被稱為虛擬的是因為它提供了一個不依賴於底層操作系統和機器硬件的接口。這種獨立於硬件和操作系統的特性正是 Java 程序可以一次編寫多處執行的原因。 3）Java 運行時環境(JRE) JRE 是 JVM 的實施實現，它提供了運行 Java 程序的平臺。JRE 包含了 JVM、Java 二進制文件和其它成功執行程序的類文件。JRE 不包含任何像 Java 編譯器、調試器之類的開發工具。如果你只是想要執行 Java 程序，你只需安裝 JRE 即可，沒有安裝 JDK 的必要。

JDK, JRE 和 JVM 的區別 JDK 是用於開發的而 JRE 是用於運行 Java 程序的。 JDK 和 JRE 都包含了 JVM，從而使得我們可以運行 Java 程序。 JVM 是 Java 編程語言的核心並且具有平臺獨立性。 即時編譯器(JIT) 有時我們會聽到 JIT 這個概念，並說它是 JVM 的一部分，這讓我們很困惑。JIT 是 JVM 的一部分，它可以在同一時間編譯類似的字節碼來優化將字節碼轉換為機器特定語言的過程相似的字節碼，從而將優化字節碼轉換為機器特定語言的過程，這樣減少轉換過程所需要花費的時間。

7.是否可以在 static 環境中訪問非 static 變量

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

Java 中的 final關鍵字用法

(1)修飾類：表示該類不能被繼承； (2)修飾方法：表示方法不能被覆蓋； (3)修飾變量：表示變量只能一次賦值以後值不能被修改（常量）。

assert

assertion(斷言)在軟件開發中是一種常用的調試方式，很多開發語言中都支持這種機制。一般來說，assertion 用於保證程序最基本、關鍵的正確性。assertion 檢查通常在開發和測試時開啟。為了提高性能，在軟件發布後， assertion 檢查通常是關閉的。在實現中，斷言是一個包含布爾表達式的語句，在執行這個語句時假定該表達式為 true；如果表達式計算為 false，那麽系統會報告一個 AssertionError。

斷言用於調試目的：

    assert(a > 0); // throws an AssertionError if a <= 0

斷言可以有兩種形式：

    assert Expression1;
    assert Expression1 : Expression2 ;

Expression1 應該總是產生一個布爾值。 Expression2 可以是得出一個值的任意表達式；這個值用於生成顯示更多調試信息的字符串消息 斷言在默認情況下是禁用的，要在編譯時啟用斷言，需使用 source 1.4 標記：

    javac -source 1.4 Test.java

要在運行時啟用斷言，可使用 -enableassertions 或者 -ea 標記。 要在運行時選擇禁用斷言，可使用 -da 或者 -disableassertions 標記。

final, finally, finalize 的區別?

final：修飾符（關鍵字）有三種用法：如果一個類被聲明為final，意味著它不能再派生出新的子類，即不能被繼承，因此它和 abstract 是反義詞。將變量聲明為 final，可以保證它們在使用中不被改變，被聲明為 final 的變量必須在聲明時給定初值，而在以後的引用中只能讀取不可修改。被聲明為 final 的方法也同樣只能使用，不能在子類中被重寫。 finally：通常放在 try…catch 的後面構造總是執行代碼塊，這就意味著程序無論正常執行還是發生異常，這裏的代碼只要 JVM 不關閉都能執行，可以將釋放外部資源的代碼寫在 finally 塊中。 finalize：Object 類中定義的方法，Java 中允許使用 finalize() 方法在垃圾收集器將對象從內存中清除出去之前做必要的清理工作。這個方法是由垃圾收集器在銷毀對象時調用的，通過重寫finalize() 方法可以整理系統資源或者執行其他清理工作。

& 和 &&

& 和 && 都可以用作邏輯與的運算符，表示邏輯與（and），當運算符兩邊的表達式的結果都為 true 時，整個運算結果才為 true，否則，只要有一方為 false，則結果為 false。 && 還具有短路的功能，即如果第一個表達式為 false，則不再計算第二個表達式.& 還可以用作位運算符，當 & 操作符兩邊的表達式不是 boolean 類型時，& 表示按位與操作.

用最有效率的方法算出 2 乘以 8 等於幾

2 << 3，因為將一個數左移 n 位，就相當於乘以了 2 的 n 次方，那麽，一個數乘以 8 只要將其左移 3 位即可，而位運算 cpu 直接支持的，效率最高，所以，2 乘以 8 等於幾的最效率的方法是 2 << 3 。

char 型變量

char 類型可以存儲一個中文漢字，因為 Java 中使用的編碼是 Unicode（不選擇任何特定的編碼，直接使用字符在字符集中的編號，這是統一的唯一方法），一個 char 類型占 2 個字節（16bit），所以放一個中文是沒問題的。 補充：使用 Unicode 意味著字符在 JVM 內部和外部有不同的表現形式，在 JVM 內部都是 Unicode，當這個字符被從 JVM 內部轉移到外部時（例如存入文件系統中），需要進行編碼轉換。所以 Java 中有字節流和字符流，以及在字符流和字節流之間進行轉換的轉換流，如 InputStreamReader 和 OutputStreamReader.

String 和StringBuilder、StringBuffer 的區別

答：Java 平臺提供了兩種類型的字符串：String 和StringBuffer / StringBuilder，它們可以儲存和操作字符串。其中 String 是只讀字符串，也就意味著 String 引用的字符串內容是不能被改變的。而 StringBuffer 和 StringBuilder 類表示的字符串對象可以直接進行修改。StringBuilder 是 JDK 1.5 中引入的，它和 StringBuffer 的方法完全相同，區別在於它是在單線程環境下使用的，因為它的所有方面都沒有被 synchronized 修飾，因此它的效率也比 StringBuffer 略高。 有一個面試題問：有沒有哪種情況用 + 做字符串連接比調用 StringBuffer / StringBuilder 對象的 append 方法性能更好？如果連接後得到的字符串在靜態存儲區中是早已存在的，那麽用+做字符串連接是優於 StringBuffer / StringBuilder 的 append 方法的。

String不可變性

至於為什麽要把 String 類設計成不可變類，是它的用途決定的。其實不只 String，很多 Java 標準類庫中的類都是不可變的。在開發一個系統的時候，我們有時候也需要設計不可變類，來傳遞一組相關的值，這也是面向對象思想的體現。不可變類有一些優點，比如因為它的對象是只讀的，所以多線程並發訪問也不會有任何問題。當然也有一些缺點，比如每個不同的狀態都要一個對象來代表，可能會造成性能上的問題。所以 Java 標準類庫還提供了一個可變版本，即 StringBuffer。 Javac 編譯可以對字符串常量直接相加的表達式進行優化，不必要等到運行期去進行加法運算處理，而是在編譯時去掉其中的加號，直接將其編譯成一個這些常量相連的結果。所以 String s=“a”+”b”+”c”+”d”;只生成一個對象.

不可變對象

如果一個對象，在它創建完成之後，不能再改變它的狀態，那麽這個對象就是不可變的。不能改變狀態的意思是，不能改變對象內的成員變量，包括基本數據類型的值不能改變，引用類型的變量不能指向其他的對象，引用類型指向的對象的狀態也不能改變。 如何創建不可變類

1. 將類聲明為final，所以它不能被繼承
2. 將所有的成員聲明為私有的，這樣就不允許直接訪問這些成員
3. 對變量不要提供setter方法
4. 將所有可變的成員聲明為final，這樣只能對它們賦值一次
5. 通過構造器初始化所有成員，進行深拷貝(deep copy):如果某一個類成員不是原始變量(primitive)或者不可變類，必須通過在成員初始化(in)或者get方法(out)時通過深度clone方法，來確保類的不可變。
6. 在getter方法中，不要直接返回對象本身，而是克隆對象，並返回對象的拷貝

http://www.cnblogs.com/yg_zhang/p/4355354.html http://www.importnew.com/7535.html

為什麽String要設計成不可變的**

在Java中將String設計成不可變的是綜合考慮到各種因素的結果,如內存,同步,數據結構以及安全等方面的考慮.

1. 字符串常量池的需要. 字符串池的實現可以在運行時節約很多heap空間，因為不同的字符串變量都指向池中的同一個字符串。但如果字符串是可變的，那麽String interning將不能實現(譯者註：String interning是指對不同的字符串僅僅只保存一個，即不會保存多個相同的字符串。)，因為這樣的話，如果變量改變了它的值，那麽其它指向這個值的變量的值也會一起改變。
2. 線程安全考慮。 同一個字符串實例可以被多個線程共享。這樣便不用因為線程安全問題而使用同步。字符串自己便是線程安全的。
3. 類加載器要用到字符串，不可變性提供了安全性，以便正確的類被加載。譬如你想加載java.sql.Connection類，而這個值被改成了myhacked.Connection，那麽會對你的數據庫造成不可知的破壞。
4. 支持hash映射和緩存。 因為字符串是不可變的，所以在它創建的時候hashcode就被緩存了，不需要重新計算。這就使得字符串很適合作為Map中的鍵，字符串的處理速度要快過其它的鍵對象。這就是HashMap中的鍵往往都使用字符串。

http://blog.csdn.net/renfufei/article/details/16808775 http://www.codeceo.com/article/why-java-string-immutable.html http://www.importnew.com/7440.html http://www.importnew.com/16817.html

什麽是 Java 序列化，如何實現 Java 序列化

序列化就是一種用來處理對象流的機制，所謂對象流也就是將對象的內容進行流化。可以對流化後的對象進行讀寫操作，也可將流化後的對象傳輸於網絡之間。序列化是為了解決在對對象流進行讀寫操作時所引發的問題。

序列化的實現：將需要被序列化的類實現 Serializable 接口，該接口沒有需要實現的方法， implements Serializable 只是為了標註該對象是可被序列化的，然後使用一個輸出流(如：FileOutputStream)來構造一個ObjectOutputStream(對象流)對象，接著，使用ObjectOutputStream對象的writeObject(Object obj)方法就可以將參數為obj的對象寫出(即保存其狀態)，要恢復的話則用輸入流。

錯誤和異常的區別(Error vs Exception)

1) java.lang.Error: Throwable 的子類，用於標記嚴重錯誤,表示系統級的錯誤和程序不必處理的異常。合理的應用程序不應該去 try/catch 這種錯誤。是恢復不是不可能但很困難的情況下的一種嚴重問題；比如內存溢出，不可能指望程序能處理這樣的情況； java.lang.Exception: Throwable 的子類，表示需要捕捉或者需要程序進行處理的異常，是一種設計或實現問題；也就是說，它表示如果程序運行正常，從不會發生的情況。並且鼓勵用戶程序去 catch 它。

2) Error 和 RuntimeException 及其子類都是未檢查的異常（unchecked exceptions），而所有其他的 Exception 類都是檢查了的異常（checked exceptions） checked exceptions: 上下文環境有關，即使程序設計無誤，仍然可能因使用的問題而引發．通常是從一個可以恢復的程序中拋出來的，並且最好能夠從這種異常中使用程序恢復。比如 FileNotFoundException, ParseException 等。檢查了的異常發生在編譯階段，必須要使用 try…catch（或者 throws ）否則編譯不通過。 unchecked exceptions:通常是如果一切正常的話本不該發生的異常，但是的確發生了。 發生在運行期，具有不確定性，主要是由於程序的邏輯問題所引起的。比如 ArrayIndexOutOfBoundException, ClassCastException 等。從語言本身的角度講，程序不該去 catch 這類異常，雖然能夠從諸如 RuntimeException 這樣的異常中 catch 並恢復，但是並不鼓勵終端程序員這麽做，因為完全沒要必要。因為這類錯誤本身就是 bug，應該被修復，出現此類錯誤時程序就應該立即停止執行。 因此，面對 Errors 和 unchecked exceptions 應該讓程序自動終止執行，程序員不該做諸如 try/catch 這樣的事情，而是應該查明原因，修改代碼邏輯。 RuntimeException：RuntimeException體系包括錯誤的類型轉換、數組越界訪問和試圖訪問空指針等等。處理 RuntimeException 的原則是：如果出現 RuntimeException，那麽一定是程序員的錯誤。例如，可以通過檢查數組下標和數組邊界來避免數組越界訪問異常。其他（IOException等等）checked 異常一般是外部錯誤，例如試圖從文件尾後讀取數據等，這並不是程序本身的錯誤，而是在應用環境中出現的外部錯誤。

try{} 裏的 return 語句

Java 允許在 finally 中改變返回值的做法是不好的，因為如果存在 finally 代碼塊，try 中的 return 語句不會立馬返回調用者，而是記錄下返回值待 finally 代碼塊執行完畢之後再向調用者返回其值，然後如果在 finally 中修改了返回值，這會對程序造成很大的困擾

運行時異常與受檢異常有何異同？

答：異常表示程序運行過程中可能出現的非正常狀態，運行時異常表示虛擬機的通常操作中可能遇到的異常，是一種常見運行錯誤，只要程序設計得沒有問題通常就不會發生。受檢異常跟程序運行的上下文環境有關，即使程序設計無誤，仍然可能因使用的問題而引發。Java編譯器要求方法必須聲明拋出可能發生的受檢異常，但是並不要求必須聲明拋出未被捕獲的運行時異常。異常和繼承一樣，是面向對象程序設計中經常被濫用的東西，神作《Effective Java》中對異常的使用給出了以下指導原則： 不要將異常處理用於正常的控制流（設計良好的API不應該強迫它的調用者為了正常的控制流而使用異常） 對可以恢復的情況使用受檢異常，對編程錯誤使用運行時異常 避免不必要的使用受檢異常（可以通過一些狀態檢測手段來避免異常的發生） 優先使用標準的異常 每個方法拋出的異常都要有文檔 保持異常的原子性 不要在 catch 中忽略掉捕獲到的異常

throws、throw、try、catch、finally

一般情況下是用 try 來執行一段程序，如果出現異常，系統會拋出（throw）一個異常，這時候你可以通過它的類型來捕捉（catch）它，或最後（finally）由缺省處理器來處理；try 用來指定一塊預防所有“異常”的程序；catch 子句緊跟在 try 塊後面，用來指定你想要捕捉的“異常”的類型；throw 語句用來明確地拋出一個“異常”；throws用來標明一個成員函數可能拋出的各種“異常”；finally 為確保一段代碼不管發生什麽“異常”都被執行一段代碼；

常見的runtime exception

1、NullPointerException 空指針引用異常 2、ClassCastException - 類型強制轉換異常。 3、IllegalArgumentException - 傳遞非法參數異常。 4、IndexOutOfBoundsException - 下標越界異常 5、UnsupportedOperationException - 不支持的操作異常 6、ArithmeticException - 算術運算異常 7、ArrayStoreException - 向數組中存放與聲明類型不兼容對象異常 8、NegativeArraySizeException - 創建一個大小為負數的數組錯誤異常 9、NumberFormatException - 數字格式異常 10、SecurityException - 安全異常

throw和throws有什麽區別

throw關鍵字用來在程序中明確的拋出異常，相反，throws語句用來表明方法不能處理的異常。每一個方法都必須要指定哪些異常不能處理，所以方法的調用者才能夠確保處理可能發生的異常，多個異常是用逗號分隔的。

Switch能否用string做參數？

Java 1.7之前不可以，java 1.7後String可以作為參數。 整型（byte，short int，int，long int），枚舉類型，boolean，字符型(char),字符串都可以，唯獨浮點型不可以

equals與==的區別

1、 == 是一個運算符。 2、Equals則是string對象的方法，可以.（點）出來。 我們比較無非就是這兩種 1、基本數據類型比較 2、引用對象比較 1、基本數據類型比較 　==比較兩個值是否相等。相等為true 否則為false； equals不能直接用於基本類型的比較。需要將基本類型轉換為包裝器進行比較。 2、引用對象比較 ==和equals都是比較棧內存中的地址是否相等 。相等為true 否則為false； 　 需註意幾點： 1、string是一個特殊的引用類型。對於兩個字符串的比較，不管是 == 和 equals 這兩者比較的都是字符串是否相同； 2、當你創建兩個string對象時，內存中的地址是不相同的，你可以賦相同的值。 　　所以字符串的內容相同。引用地址不一定相同，（相同內容的對象地址不一定相同），但反過來卻是肯定的； 3、基本數據類型比較(string 除外) == 和 Equals 兩者都是比較值；

Object有哪些公用方法

protected Object clone()創建並返回此對象的一個副本。 public boolean equals(Object obj)指示其他某個對象是否與此對象“相等”。 protected void finalize()當垃圾回收器確定不存在對該對象的更多引用時，由對象的垃圾回收器調用此方法。 public final native Class< ? > getClass() 返回此 Object 的運行時類。 public int hashCode()返回該對象的哈希碼值。 public String toString()返回該對象的字符串表示。 public void notify()喚醒在此對象監視器上等待的單個線程。 public void notifyAll()喚醒在此對象監視器上等待的所有線程。 public void wait()在其他線程調用此對象的 notify() 方法或 notifyAll() 方法前，導致當前線程等待。 public void wait(long timeout)在其他線程調用此對象的 notify() 方法或 notifyAll() 方法，或者超過指定的時間量前，導致當前線程等待。 public void wait(long timeout, int nanos)在其他線程調用此對象的 notify() 方法或

註意： 1.如果一個類實現了Cloneable,Object的clone方法就返回該對象的逐域拷貝，否則就會拋出CloneNotSupportException異常。java.lang.Cloneable 是一個標示性接口，不包含任何方法（詳見《effective java》 p46）。

1. 覆蓋equals（）時總要覆蓋hashCode（）（詳見《effective java》p39） 在每個覆蓋equals方法的類中也必須覆蓋hashCode方法，如果不這樣做就會導致Object.hashCode的通用約定---相等的對象必須具有相等的散列碼的約定，從而導致該類無法集合所有基於散列集合一起工作，這樣的集合有HashMap,HashSet和HashTable。HashMap等使用Key對象的hashCode()和equals()方法去決定key-value對的索引。如果將equals相等的對象認為是同一個對象的話，那麽put方法將對象放在一個散列桶，而get方法可能從另一個散列桶獲取該對象，因為這兩個方法傳入的對象雖然equals相同，但hashCode可能不同，而hashMap根據hashCode去定位散列桶位置導致出現在不同的散列桶中。 Hashcode的作用。
2. hashCode的存在主要是用於查找的快捷性，如Hashtable，HashMap等，hashCode是用來在散列存儲結構中確定對象的存儲地址的；
3. 比較對象是否相同。 一下是關於hashCode的約定： 1、如果兩個對象相同，就是適用於equals(java.lang.Object) 方法，那麽這兩個對象的hashCode一定要相同； 2、如果對象的equals方法被重寫，那麽對象的hashCode也盡量重寫，並且產生hashCode使用的對象，一定要和equals方法中使用的一致，否則就會違反上面提到的第2點； 3、兩個對象的hashCode相同，並不一定表示兩個對象就相同，也就是不一定適用於equals(java.lang.Object) 方法，只能夠說明這兩個對象在散列存儲結構中，如Hashtable，他們“存放在同一個籃子裏”。

String、StringBuffer與StringBuilder的區別

1. String是字符串常量，是不可變類。如果要操作少量的數據用
2. StringBuffer是字符串變量，是線程安全的。多線程操作字符串緩沖區 下操作大量數據
3. StringBuilder是字符串變量，非線程安全。單線程操作字符串緩沖區 下操作大量數據 速度：StringBuilder > StringBuffer > String String 對象的字符串拼接其實是被 JVM 解釋成了 StringBuffer 對象的拼接，所以這些時候 String 對象的速度並不會比 StringBuffer 對象慢，而特別是以下的字符串對象生成中， String 效率是遠要比 StringBuffer 快的： String S1 = “This is only a” + “ simple” + “ test”; StringBuffer Sb = new StringBuilder(“This is only a”).append(“simple”).append(“ test”); 參見：http://www.findspace.name/easycoding/1090

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

1)不管有木有出現異常，finally塊中代碼都會執行 2)當try和catch中有return時，finally仍然會執行 3)finally是在return後面的表達式運算後執行的（此時並沒有返回運算後的值，而是先把要返回的值保存起來，不管finally中的代碼怎麽樣，返回的值都不會改變，任然是之前保存的值），所以函數返回值是在finally執行前確定的 4)finally中最好不要包含return，否則程序會提前退出，返回值不是try或catch中保存的返回值

UnsupportedOperationException是什麽

UnsupportedOperationException是用於表明操作不支持的異常。在JDK類中已被大量運用，在集合框架java.util.Collections.UnmodifiableCollection將會在所有add和remove操作中拋出這個異常。

Excption與Error包結構

java值傳遞問題

1.對象就是傳引用 2.原始類型就是傳值 3.String，Integer, Double等immutable類型因為沒有提供自身修改的函數，每次操作都是新生成一個對象，所以要特殊對待。可以認為是傳值。 Integer 和 String 一樣。保存value的類變量是Final屬性，無法被修改，只能被重新賦值／生成新的對象。 當Integer 做為方法參數傳遞進方法內時，對其的賦值都會導致 原Integer 的引用被 指向了方法內的棧地址，失去了對原類變量地址的指向。對賦值後的Integer對象做得任何操作，都不會影響原來對象。

Integer

http://www.cnblogs.com/dolphin0520/p/3780005.html

修飾符順序

public protected private abstract static final transient volatile synchronized native strictfp

Java面試準備之Java基礎