JAVA 對象引用，以及對象賦值

關鍵字: 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對象和引用的概念，以及與其密切相關的參數傳遞。

先看下面的程序：

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");

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

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

 

上面的程序表明，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出來的是對象。
在后面的左右都是引用的“=”語句時，左右的引用同時指向了右邊引用所指向的對象。

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

 

如果需要賦值，就需要類實現Cloneable接口，實現clone()方法。

    class D implements Cloneable {// 實現Cloneable接口
        String sex;

        D(String sex) {
            this.sex = sex;
        }

        @Override
        protected Object clone() throws CloneNotSupportedException {
            // 實現clone方法
            return super.clone();
        }
    }

 

賦值的時候：

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

如果類中的變量不是主類型，而是對象，也需要調用該對象的clone()方法
下面是一個完整的例子：

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();
    }
}

 

補充： 

關於Java對象作為參數傳遞是傳值還是傳引用的問題

前言

　　

　　值傳遞：就是在方法調用的時候，實參是將自己的一份拷貝賦給形參，在方法內，對該參數值的修改不影響原來實參。

　　引用傳遞：是在方法調用的時候，實參將自己的地址傳遞給形參，此時方法內對該參數值的改變，就是對該實參的實際操作。

　　在Java中，當對象作為參數傳遞時，究竟傳遞的是對象的值，還是對象的引用，這是一個飽受爭議的話題。若傳的是值，那么函數接收的只是實參的一個副本，函數對形參的操作並不會對實參產生影響；若傳的是引用，那么此時對形參的操作則會影響到實參。 
　　首先我們來看一句代碼：

Object obj = new Object(); 

　　這句話的意思是：創建一個Object對象，再創建一個名為obj的引用，讓這個引用指向這個對象，如下圖所示：

　　

在有了上面的基礎之后，我們便來看下面這組在網上很流行的例子：

基本數據類型作為參數傳遞：

例1：

public class test {
    
    public static void main(String[] args) {
        int i = 1;
        System.out.println("before change, i = " + i);
        change(i);
        System.out.println("after change, i = " + i);

    }

    public static void change(int i) {
        i = 5;
    }
}

 

　　這個例子不難理解，當基本數據類型作為參數傳遞時，傳遞的是實參值的副本，即傳的是值，無論在函數中怎么操作這個副本，實參的值是不會被改變的。所以以上代碼執行的結果是： 
　

     before change, i = 1 
　  　after change, i = 1 

 

對象作為參數傳遞：

　　在下面的例２中，我們把StringBuffer對象作為參數傳遞到change函數。 
　　 
　　例2：

　　

public class test {

    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("Hello ");
        System.out.println("before change, sb is " + sb.toString());
        change(sb);
        System.out.println("after change, sb is " + sb.toString());
    }

    public static void change(StringBuffer stringBuffer) {
        stringBuffer.append("world !");
    }
}

 

　　為了方便推理出結論，我們先直接看程序的運行結果： 

　before change, sb is Hello 
　after change, sb is Hello world ! 　　 

　　從輸出結果中我們可以發現，sb所指向的對象的值被改變了，那么是否我們可以推論出，在Java中，當對象作為參數傳遞時，傳遞的是該對象的引用呢？我們再來看下面這個例子： 
　　 
　　例3：

  　　

public class test {

    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("Hello ");
        System.out.println("before change, sb is " + sb.toString());
        change(sb);
        System.out.println("after change, sb is " + sb.toString());
    }

    public static void change(StringBuffer stringBuffer) {
        stringBuffer = new StringBuffer("Hi ");
        stringBuffer.append("world !");
    }
}

 

　　如果上面的推論是正確的，即Java中對象作為參數傳遞，實際傳遞的是該對象的引用，那么在調用change函數之后，原對象的值應該是會改變的，變為“Hi world ！”，但是，當我們運行程序后，結果卻是如下所示： 

　　 
　　before change, sb is Hello 
　　after change, sb is Hello 
　　 
　　原對象的值並沒有被改變，這與上面的推論相矛盾！為什么在Java中，當對象作為參數傳遞時，有的時候實參被改變了，而有的時候實參並未被改變呢？下面讓我們來分析一下其中的原因： 
　　從文章的開頭我們知道，當執行StringBuffer sb = new StringBuffer(“Hello “)時，我們創建了一個指向新建對象“new StringBuffer(“Hello “)”的引用“sb”，如下圖所示： 
　　 
　　 
　　 
　　在例2中，當我們調用change函數后，實際上，形參stringBuffer也指向了實參sb所指向的對象，即： 
　　 
　　 
　　 
　　那么當我們執行stringBuffer.append(“world !”)后，便通過對象的引用“stringBuffer”修改了對象的值，使之變成了“Hello world ！”，即： 
　　 
　　 
　　 
　　但是，在例3中的change函數中，我們又新建了一個對象“new StringBuffer(“Hi “)”（這實際上在內存中開辟了一塊在原對象地址之外的新區域），這讓形參stringBuffer實際指向了這個新建的對象，並將新對象的值設置為“Hi world ！”，即： 
　　 
　　 
　　 
　　那么我們就不難理解，為何在執行完change函數之后，實參的值仍為“Hello”了。 
　　

結論

　　綜上所述，我們可以得出結論：在Java中，當對象作為參數傳遞時，實際上傳遞的是一份“引用的拷貝”。

綜合其實傳的就是值，只不過是引用的值。

 

原文地址 : https://blog.csdn.net/lshow1999/article/details/72785380

補充原文地址 :https://blog.csdn.net/qq_28081081/article/details/80400111