本文是最近在複習Java的時候讀到的來自iteye部落格的一篇文章，個人覺得寫的很好，但貌似樓主許久沒有維護該部落格，害怕將來想回顧的時候找不到此文章，故在此重寫文章，並修改了一些排版，有助於以後的學習查閱。

一、關於物件與引用之間的一些基本概念

  為便於說明，先定義一個類：

class Vehicle {
    int passengers;

    int fuelcap;

    int mpg;
}

  有了這個類，就可以用它來建立物件：Vehicle veh1 = new Vehicle()，通常把這條語句的動作稱之為建立一個物件，其實，它包含了四個動作：

• 右邊的new Vehicle
  ，是以Vehicle類為模板，在堆空間裡建立一個Vehicle類物件（也簡稱為Vehicle物件）
• 末尾的()意味著，在物件建立後，立即呼叫Vehicle類的建構函式，對剛生成的物件進行初始化。建構函式是肯定有的。如果你沒寫，Java會給你補上一個預設的建構函式
• 左邊的Vehicle veh1建立了一個Vehicle類引用變數。所謂Vehicle類引用，就是以後可以用來指向Vehicle物件的物件引用
• =操作符使物件引用指向剛建立的那個Vehicle物件

  我們可以把這條語句拆成兩部分：

1. Vehicle veh1;

2. veh1 = new Vehicle();

  效果是一樣的。這樣寫，就比較清楚了，有兩個實體：一是物件引用變數，一是物件本身。

  在堆空間裡建立的實體，與在資料段以及棧空間裡建立的實體不同。儘管它們也是確確實實存在的實體，但是，我們看不見，也摸不著。不僅如此，

  我們仔細研究一下第二句，找找剛建立的物件叫什麼名字？有人說，它叫“Vehicle”。不對，“Vehicle”是類（物件的建立模板）的名字。

  一個Vehicle類可以據此創建出無數個物件，這些物件不可能全叫“Vehicle”。

  物件連名都沒有，沒法直接訪問它。我們只能通過物件引用來間接訪問物件。

  為了形象地說明物件、引用及它們之間的關係，可以做一個或許不很妥當的比喻。物件好比是一隻很大的氣球，大到我們抓不住它。引用變數是一根繩， 可以用來系汽球。

  如果只執行了第一條語句，還沒執行第二條，此時建立的引用變數veh1還沒指向任何一個物件，它的值是null。引用變數可以指向某個物件，或者為null。

  它是一根繩，一根還沒有繫上任何一個汽球的繩。執行了第二句後，一隻新汽球做出來了，並被系在veh1這根繩上。我們抓住這根繩，就等於抓住了那隻汽球。

  再來一句：

​ Vehicle veh2;

  就又做了一根繩，還沒繫上汽球。如果再加一句：

​ veh2 = veh1;

  繫上了。這裡發生了複製行為。但是，要說明的是，物件本身並沒有被複制，被複制的只是物件引用。結果是，veh2也指向了veh1所指向的物件。兩根繩系的是同一只汽球。

  如果用下句再建立一個物件：

​ veh2 = new Vehicle();

  則引用變數veh2改指向第二個物件。

  從以上敘述再推演下去，我們可以獲得以下結論：

1. 一個物件引用可以指向0個或1個物件（一根繩子可以不繫汽球，也可以系一個汽球）

2. 一個物件可以有N個引用指向它（可以有N條繩子繫住一個汽球）

  如果再來下面語句：

​ veh1 = veh2;

  按上面的推斷，veh1也指向了第二個物件。這個沒問題。問題是第一個物件呢？沒有一條繩子繫住它，它飛了。多數書裡說，它被Java的垃圾回收機制回收了。

  這不確切。正確地說，它已成為垃圾回收機制的處理物件。至於什麼時候真正被回收，那要看垃圾回收機制的心情了。

  由此看來，下面的語句應該不合法吧？至少是沒用的吧？

​ new Vehicle();

  不對。它是合法的，而且可用的。譬如，如果我們僅僅為了列印而生成一個物件，就不需要用引用變數來繫住它。最常見的就是列印字串：

​ System.out.println(“I am Java!”);

  字串物件“I am Java!”在列印後即被丟棄。有人把這種物件稱之為臨時物件。

  物件與引用的關係將持續到物件回收。

二、Java物件及引用

  Java物件及引用是容易混淆卻又必須掌握的基礎知識，本章闡述Java物件和引用的概念，以及與其密切相關的引數傳遞。

  先看下面的程式：

StringBuffer s;
s = new StringBuffer("Hello World!");

  第一個語句僅為引用(reference)分配了空間，而第二個語句則通過呼叫類(StringBuffer)的建構函式StringBuffer(String str)為類生成了一個例項（或稱為物件）。這兩個操作被完成後，物件的內容則可通過s進行訪問——在Java裡都是通過引用來操縱物件的。

  Java物件和引用的關係可以說是互相關聯，卻又彼此獨立。彼此獨立主要表現在：引用是可以改變的，它可以指向別的物件，譬如上面的s，你可以給它另外的物件，如：

​ s = new StringBuffer("Java");

  這樣一來，s就和它指向的第一個物件脫離關係。

  從儲存空間上來說，物件和引用也是獨立的，它們儲存在不同的地方，物件一般儲存在堆中，而引用儲存在速度更快的堆疊中。

  引用可以指向不同的物件，物件也可以被多個引用操縱，如：

​ StringBuffer s1 = s;

  這條語句使得s1和s指向同一個物件。既然兩個引用指向同一個物件，那麼不管使用哪個引用操縱物件，物件的內容都發生改變，並且只有一份，通過s1和s得到的內容自然也一樣，（String除外，因為String始終不變，String s1=”AAAA”; String s=s1，操作s，s1由於始終不變，所以為s另外開闢了空間來儲存s）如下面的程式：

StringBuffer s;  
  
s = new StringBuffer("Java");  
  
StringBuffer s1 = s;  
  
s1.append(" World");  

//列印結果為：s1=Java World
System.out.println("s1=" + s1.toString());  

//列印結果為：s=Java World  
System.out.println("s=" + s.toString()); 

  上面的程式表明，s1和s打印出來的內容是一樣的，這樣的結果看起來讓人非常疑惑，但是仔細想想，s1和s只是兩個引用，它們只是操縱桿而已，它們指向同一個物件，操縱的也是同一個物件，通過它們得到的是同一個物件的內容。這就像汽車的剎車和油門，它們操縱的都是車速，假如汽車開始的速度是80，然後你踩了一次油門，汽車加速了，假如車速升到了120，然後你踩一下剎車，此時車速是從120開始下降的，假如下降到60，再踩一次油門，車速則從60開始上升，而不是從第一次踩油門後的120開始。也就是說車速同時受油門和剎車影響，它們的影響是累積起來的，而不是各自獨立（除非剎車和油門不在一輛車上）。所以，在上面的程式中，不管使用s1還是s操縱物件，它們對物件的影響也是累積起來的（更多的引用同理）。

三、只有理解了物件和引用的關係，才能理解引數傳遞

  一般面試題中都會考Java傳參的問題，並且它的標準答案是Java只有一種引數傳遞方式：那就是按值傳遞，即Java中傳遞任何東西都是傳值。如果傳入方法的是基本型別的東西，你就得到此基本型別的一份拷貝。如果是傳遞引用，就得到引用的拷貝。

  一般來說，對於基本型別的傳遞，我們很容易理解，而對於物件，總讓人感覺是按引用傳遞，看下面的程式：

public class ObjectRef {  
  
    //基本型別的引數傳遞  
    public static void testBasicType(int m) {  
        System.out.println("m=" + m);//m=50  
        m = 100;  
        System.out.println("m=" + m);//m=100  
    }     
  
    //引數為物件，不改變引用的值 ？？？？？？  
    public static void add(StringBuffer s) {  
        s.append("_add");  
    }   
  
    //引數為物件，改變引用的值 ？？？？？  
    public static void changeRef(StringBuffer s) {  
        s = new StringBuffer("Java"); 
    }  
       
    public static void main(String[] args) {  
        int i = 50;  
        testBasicType(i);  
        System.out.println(i);//i=50  
        StringBuffer sMain = new StringBuffer("init");  
        System.out.println("sMain=" + sMain.toString());//sMain=init  
        add(sMain);  
        System.out.println("sMain=" + sMain.toString());//sMain=init_add  
        changeRef(sMain);  
        System.out.println("sMain=" + sMain.toString());//sMain=init_add   
    }   
} 

  以上程式的允許結果顯示出，testBasicType方法的引數是基本型別，儘管引數m的值發生改變，但並不影響i。

  add方法的引數是一個物件，當把sMain傳給引數s時，s得到的是sMain的拷貝，所以s和sMain指向同一個物件，因此，使用s操作影響的其實就是sMain指向的物件，故呼叫add方法後，sMain指向的物件的內容發生了改變。

  在changeRef方法中，引數也是物件，當把sMain傳給引數s時，s得到的是sMain的拷貝，但與add方法不同的是，在方法體內改變了s指向的物件（也就是s指向了別的物件,牽著氣球的繩子換氣球了），給s重新賦值後，s與sMain已經毫無關聯，它和sMain指向了不同的物件，所以不管對s做什麼操作，都不會影響sMain指向的物件，故呼叫changeRef方法前後sMain指向的物件內容並未發生改變。

  對於add方法的呼叫結果，可能很多人會有這種感覺：這不明明是按引用傳遞嗎？對於這種問題，還是套用Bruce Eckel的話：這依賴於你如何看待引用，最終你會明白，這個爭論並沒那麼重要。真正重要的是，你要理解，傳引用使得（呼叫者的）物件的修改變得不可預期。

public class Test {
    public int i, j;

    public void test_m(Test a) {
	Test b = new Test();
	b.i = 1;
	b.j = 2;
	a = b;
    }

    public void test_m1(Test a) {
	a.i = 1;
	a.j = 2;
    }

    public static void main(String argv[]) {
	Test t = new Test();
	t.i = 5;
	t.j = 6;
	System.out.println("t.i=" + t.i + "  t.j=" + t.j); // 5,6
	t.test_m(t);
	System.out.println("t.i=" + t.i + "  t.j=" + t.j); // 5,6,a和t都指向了一個物件，而在test_m中s又指向了另一個物件，所以物件t不變！！！
	t.test_m1(t);
	System.out.println("t.i=" + t.i + "  t.j=" + t.j); // 1,2
    }
	
}

  答案只有一個：Java裡都是按值傳遞引數。而實際上，我們要明白，當引數是物件時，傳引用會發生什麼狀況（就像上面的add方法）？

總結：

  如下表達式：
A a1 = new A();
  它代表A是類，a1是引用，a1不是物件，new A()才是物件，a1引用指向new A()這個物件。

  在JAVA裡，“=”不能被看成是一個賦值語句，它不是在把一個物件賦給另外一個物件，它的執行過程實質上是將右邊物件的地址傳給了左邊的引用，使得左邊的引用指向了右邊的物件。Java表面上看起來沒有指標，但它的引用其實質就是一個指標，引用裡面存放的並不是物件，而是該物件的地址，使得該引用指向了物件。在Java裡，“=”語句不應該被翻譯成賦值語句，因為它所執行的確實不是一個賦值的過程，而是一個傳地址的過程，被譯成賦值語句會造成很多誤解，譯得不準確。

  再如：
A a2;
  它代表A是類，a2是引用，a2不是物件，a2所指向的物件為空null;

  再如：
a2 = a1;
  它代表，a2是引用，a1也是引用，a1所指向的物件的地址傳給了a2(傳址），使得a2和a1指向了同一物件。

  綜上所述，可以簡單的記為，在初始化時，“=”語句左邊的是引用，右邊new出來的是物件。
在後面的左右都是引用的“=”語句時，左右的引用同時指向了右邊引用所指向的物件。

  再所謂例項，其實就是物件的同義詞