Java對象及其引用 (1)

標籤：表達   儲存   另一個   傳遞方式   一點   常見   bsp   執行   爭論   

Java對象及其引用 

[文章轉載自：http://zwmf.iteye.com/blog/1738574]

說明：所有轉載為個人學習存檔使用，凡轉載內容均註明轉載出處。以後不再說明.

 

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

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



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



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

StringBuffer s1 = s; 

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

Java代碼  

1. StringBuffer s;  
2.   
3. s = new StringBuffer("Java");  
4.   
5. StringBuffer s1 = s;  
6.   
7. s1.append(" World");  
8.   
9. System.out.println("s1=" + s1.toString());//列印結果為：s1=Java World  
10.   
11. System.out.println("s=" + s.toString());//列印結果為：s=Java World  
12.   
13.     

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



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

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



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

Java代碼  

1. public class ObjectRef {  
2.   
3.    
4.   
5.     //基本類型的參數傳遞  
6.   
7.     public static void testBasicType(int m) {  
8.   
9.         System.out.println("m=" + m);//m=50  
10.   
11.         m = 100;  
12.   
13.         System.out.println("m=" + m);//m=100  
14.   
15.     }  
16.   
17.      
18.   
19.     //參數為對象，不改變引用的值 ？？？？？？  
20.   
21.     public static void add(StringBuffer s) {  
22.   
23.         s.append("_add");  
24.   
25.     }  
26.   
27.      
28.   
29.     //參數為對象，改變引用的值 ？？？？？  
30.   
31.     public static void changeRef(StringBuffer s) {  
32.   
33.         s = new StringBuffer("Java");  
34.   
35.     }  
36.   
37.      
38.   
39.     public static void main(String[] args) {  
40.   
41.         int i = 50;  
42.   
43.         testBasicType(i);  
44.   
45.         System.out.println(i);//i=50  
46.   
47.         StringBuffer sMain = new StringBuffer("init");  
48.   
49.         System.out.println("sMain=" + sMain.toString());//sMain=init  
50.   
51.         add(sMain);  
52.   
53.         System.out.println("sMain=" + sMain.toString());//sMain=init_add  
54.   
55.         changeRef(sMain);  
56.   
57.         System.out.println("sMain=" + sMain.toString());//sMain=init_add  
58.   
59.     }  
60.   
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的話：這依賴於你如何看待引用，最終你會明白，這個爭論並沒那麼重要。真正重要的是，你要理解，傳引用使得（調用者的）對象的修改變得不可預期。 

Java代碼  

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不變！！！  
20.   
21.           t.test_m1(t);  
22.   
23.           System.out.println( "t.i   =   "+   t.i   +   "   t.j=   "   +   t.j); //1,2  
24.   
25.     }  
26.   
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對象及其引用 (1)