Java 對象 引用,equal == string

之前確實一直沒注意這個概念,此次看了帖子才知道。面試

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

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,)   不理解?舉例以下:less

以下面的程序:能夠解釋上面的內容函數

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

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

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

相關文章
相關標籤/搜索