JAVA 對象引用，以及對象賦值（轉）

時間 2019-11-24

標籤 java 對象引用以及賦值欄目 Java 简体版

原文原文鏈接

原文連接：http://zwmf.iteye.com/blog/1738574java

關鍵字: java對象引用

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

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

引用能夠指向不一樣的對象，對象也能夠被多個引用操縱，如：

StringBuffer s1 = s;

這條語句使得s1和s指向同一個對象。既然兩個引用指向同一個對象，那麼無論使用哪一個引用操縱對象，對象的內容都發生改變，而且只有一份，經過s1和s獲得的內容天然也同樣，(String除外，由於String始終不變，String s1=」AAAA」; String s=s1,操做s,s1因爲始終不變，因此爲s另外開闢了空間來存儲s,)以下面的程序：面試

 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中傳遞任何東西都是傳值。若是傳入方法的是基本類型的東西，你就獲得此基本類型的一份拷貝。若是是傳遞引用，就獲得引用的拷貝。

通常來講，對於基本類型的傳遞，咱們很容易理解，而對於對象，總讓人感受是按引用傳遞，看下面的程序： app

 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的話：這依賴於你如何看待引用，最終你會明白，這個爭論並沒那麼重要。真正重要的是，你要理解，傳引用使得（調用者的）對象的修改變得不可預期。函數

 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出來的是對象。
在後面的左右都是引用的「=」語句時，左右的引用同時指向了右邊引用所指向的對象。

再所謂實例，其實就是對象的同義詞。spa