以前確實一直沒註意這個概念，這次看了帖子才知道。

轉載於：https://zwmf.iteye.com/blog/1738574

Java對象及其引用

關於對象與引用之間的一些基本概念。

初學Java時，在很長一段時間裏，總覺得基本概念很模糊。後來才知道，在許多Java書中，把對象和對象的引用混為一談。可是，如果我分不清對象與對象引用，

那實在沒法很好地理解下面的面向對象技術。把自己的一點認識寫下來，或許能讓初學Java的朋友們少走一點彎路。

為便於說明，我們先定義一個簡單的類：

class Vehicle {

int passengers;

int fuelcap;

int mpg;

}

有了這個模板，就可以用它來創建對象：

Vehicle veh1 = new Vehicle();

通常把這條語句的動作稱之為創建一個對象，其實，它包含了四個動作。

1）右邊的“new Vehicle”，是以Vehicle類為模板，在堆空間裏創建一個Vehicle類對象（也簡稱為Vehicle對象）。

2）末尾的()意味著，在對象創建後，立即調用Vehicle類的構造函數，對剛生成的對象進行初始化。構造函數是肯定有的。如果你沒寫，Java會給你補上一個默認的構造函數。

3）左邊的“Vehicle veh 1”創建了一個Vehicle類引用變量。所謂Vehicle類引用，就是以後可以用來指向Vehicle對象的對象引用。

4）“=”操作符使對象引用指向剛創建的那個Vehicle對象。

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

Vehicle veh1;

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就和它指向的第一個對象脫離關系。

從存儲空間上來說，對象和引用也是獨立的，它們存儲在不同的地方，對象一般存儲在堆中，而引用存儲在速度更快的堆棧中。 對於這個存儲位置一直不清楚？？？

如下面的程序：可以解釋上面的內容

 1 package lesson;
 2 
 3 public class StringDemo {
 
 4     
 5 /*  1： String類不可變，對String對象的任何改變都不影響到源對象，相關的任何change操作都會生成新的對象。
 6         當String對象被創建後，這個對象的狀態就不能被改變，包括對象內的成員變量等都不能被改變。
 7         當創建一個字符串常量時，判斷該字符串是否在常量池中，如果存在，返回已經存在的字符串引用，
 8         如果不存在，新建一個字符串返回其引用。例如String a=“abc”；String b=“abc”；。
 9         變量a和b其實引用的是同一個字符串對象abc，如果String是可變的，有需要再創建一個新的變量。
 
10     2:  String 對equal（）進行了重寫，所以String用equal進行比較時，是比較對象的值是否相等。    
11     3:  對於8種基本數據類型，變量直接存儲的就是當前值，因此再用關系操作符==來進行比較時，比較的就是值。
12         對於非基本數據類型，我們稱之為“引用類型變量”，引用類型變量存儲的並不是指本身，而是其關聯對象在內存中的地址。
13     4:  == 比較兩個值是否相等。如果作用於基本數據類型，比較其值是否相等。如果作用於引用類型變量，則比較的是所指向對象的地址。
14     5:  在object中equal,equal方法是用來比較兩個對象的引用是否相等，即是否指向同一個對象。但是有一些類例如String,Double
15         Date,Interger等，都對equal方法進行了重寫用來比較應用的對象所存儲的值是否相等。註意equal不能用於基本數據類型。
16     6： 通過new關鍵字來生成對象是在堆去進行的，而在堆區進行對象生成過程中是不會檢測該對象是否已經存在的，因此通過new來創建對象，
17         創見出的對象肯定是不同的對象，即使字符串的內容相同
18 */    
19     public static void main(String[] args) {
20         StringBuffer sb = new StringBuffer("Java");
21         StringBuffer sb2 = sb;
22                 
23         StringBuffer sb3 = new StringBuffer("Java");
24         
25         boolean result = sb3.equals(sb2);  
26         // false 不想String對equal進行重寫，明顯這是兩個不同對象，顧不相等
27         
28         System.out.println(sb);
29         
30         String str = new String();
31         String str2 = str;
32         str2.toLowerCase();
33                 
34         String str3 = "abc";
35         String str4 = "abc";
36         String str5 = new String("abc");
37         
38         boolean flag = (str3==str4);    //true
39         boolean flag1 = (str3==str5);   //false   ==比較的是兩個值,兩個不同對象
40         boolean flag2 = str5.equals(str3);//true   String重寫equal,比較的是String裏面的值是否相等
41         
42     }
43 }

只有理解了對象和引用的關系，才能理解參數傳遞。

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

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

1. public class ObjectRef {
5. //基本類型的參數傳遞
7. public static void testBasicType(int m) {
9. System.out.println("m=" + m);//m=50
11. m = 100;
13. System.out.println("m=" + m);//m=100
15. }
19. //參數為對象，不改變引用的值 ？？？？？？
21. public static void add(StringBuffer s) {
23. s.append("_add");
25. }
29. //參數為對象，改變引用的值 ？？？？？
31. public static void changeRef(StringBuffer s) {
33. s = new StringBuffer("Java");
35. }
39. public static void main(String[] args) {
41. int i = 50;
43. testBasicType(i);
45. System.out.println(i);//i=50
47. StringBuffer sMain = new StringBuffer("init");
49. System.out.println("sMain=" + sMain.toString());//sMain=init
51. add(sMain);
53. System.out.println("sMain=" + sMain.toString());//sMain=init_add
55. changeRef(sMain);
57. System.out.println("sMain=" + sMain.toString());//sMain=init_add
59. }
61. }

以上程序的允許結果顯示出，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的話：這依賴於你如何看待引用，最終你會明白，這個爭論並沒那麽重要。真正重要的是，你要理解，傳引用使得（調用者的）對象的修改變得不可預期。

1. public class Test
2. { public int i,j;
3. public void test_m(Test a)
4. { Test b = new Test();
5. b.i = 1;
6. b.j = 2;
7. a = b;
8. }
9. public void test_m1(Test a )
10. { a.i = 1;
11. a.j = 2;
12. }
13. public static void main(String argv[])
14. { Test t= new Test();
15. t.i = 5;
16. t.j = 6;
17. System.out.println( "t.i = "+ t.i + " t.j= " + t.j); //5,6
18. t.test_m(t);
19. System.out.println( "t.i = "+ t.i + " t.j= " + t.j); //5,6,a和t都指向了一個對象，而在test_m中s又指向了另一個對象，所以對象t不變！！！
21. t.test_m1(t);
23. System.out.println( "t.i = "+ t.i + " t.j= " + t.j); //1,2
25. }
27. }

答案只有一個：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出來的是對象。
在後面的左右都是引用的“=”語句時，左右的引用同時指向了右邊引用所指向的對象。

Java 對象 引用，equal == string