1. 程式人生 > >物件引用和物件賦值

物件引用和物件賦值

關鍵字: 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;

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

StringBuffer s;

s = new StringBuffer("Java");

StringBuffer s1 = s;

s1.append(" World");

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

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

上面的程式表明,s1s打印出來的內容是一樣的,這樣的結果看起來讓人非常疑惑,但是仔細想想,s1s只是兩個引用,它們只是操縱桿而已,它們指向同一個物件,操縱的也是同一個物件,通過它們得到的是同一個物件的內容。這就像汽車的剎車和油門,它們操縱的都是車速,假如汽車開始的速度是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的拷貝,所以ssMain指向同一個物件,因此,使用s操作影響的其實就是sMain指向的物件,故呼叫add方法後,sMain指向的物件的內容發生了改變。

 在changeRef方法中,引數也是物件,當把sMain傳給引數s時,s得到的是sMain的拷貝,但與add方法不同的是,在方法體內改變了s指向的物件(也就是s指向了別的物件,牽著氣球的繩子換氣球了),給s重新賦值後,ssMain已經毫無關聯,它和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,
at都指向了一個物件,而在test_ms又指向了另一個物件,所以物件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出來的是物件。
在後面的左右都是引用的“=”語句時,左右的引用同時指向了右邊引用所指向的物件。

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

如果需要賦值,就需要類實現Cloneable介面,實現clone()方法。

1
2
3
4
5
6
7
8
9
10
11
class D implements Cloneable{//實現Cloneable介面
	String sex;
	D(String sex){
		this.sex=sex;
	}
	@Override
	protected Object clone() throws CloneNotSupportedException {
		// 實現clone方法
		return super.clone();
	}
}

賦值的時候:

1
2
D d=new D("男");
D d2=(D) d.clone();//把d賦值給d2

如果類中的變數不是主型別,而是物件,也需要呼叫該物件的clone()方法
下面是一個完整的例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public class Test2 {
	public static void main(String[] args) throws CloneNotSupportedException {
		// TODO Auto-generated method stub
		D d=new D("男");
		C c=new C("張三","20",d);
		C new_c=(C) c.clone();//呼叫clone方法來賦值
		new_c.name="李四";
		d.sex="女";//d
		System.out.println(c.d.sex);
		System.out.println(c.name);
 
	}
 
}
 
class C implements Cloneable{
	String name;
	String age;
	D d;
	C(String name,String age,D d) throws CloneNotSupportedException{
		this.name=name;
		this.age=age;
		this.d=(D) d.clone();//呼叫clone方法來賦值,這樣即便外部的d發生變化,c裡的也不會變
	}
	@Override
	protected Object clone() throws CloneNotSupportedException {
		// TODO Auto-generated method stub
		return super.clone();
	}
}
class D implements Cloneable{//實現Cloneable介面
	String sex;
	D(String sex){
		this.sex=sex;
	}
	@Override
	protected Object clone() throws CloneNotSupportedException {
		// 實現clone方法
		return super.clone();
	}
}