或許大家java的多態問題，對上溯,下溯造型有了一定的概念,對protected和private大家想必也很清楚,但是,這幾個個結合在一起,往往令人產生很多困惑,在這里,我舉一個例子,大家或許會發覺這篇文章對你來說還是很有意義的:
例子一共有兩個class.可能出現困惑的地方我都會在后面一一解釋.
A是一個父類,B繼承A,并且實現了protectedTest(Objectobj)方法.如下面所示:
B.java的源代碼:
packagecn.org.matrix.test;
importcn.org.matrix.test.A;
/**
*<p>Title:protect,privateandupcasting</p>
*<p>Description:email:chris@matrix.org.cn</p>
*<p>Copyright:MatrixCopyright(c)2003</p>
*<p>Company:Matrix.org.cn</p>
*@authorchris
*@version1.0,whousethisexampleplsremainthedeclare
*/
publicclassBextendsA
{
protectedintprotectedb=0;
protectedintprotectedab=0;


protectedvoidprotectedTest(Objectobj)
{
System.out.println("inB.protectedTest(Object):"+obj);
}
}

A.java的源代碼:
packagecn.org.matrix.test;
importcn.org.matrix.test.B;
/**
*<p>Title:protect,privateandupcasting</p>
*<p>Description:email:chris@matrix.org.cn</p>
*<p>Copyright:MatrixCopyright(c)2003</p>
*<p>Company:Matrix.org.cn</p>
*@authorchris
*@version1.0,whousethisexampleplsremainthedeclare
*/

publicclassA
{
protectedintprotecteda=0;
protectedintprotectedab=0;
privatevoidprivateTest()
{
System.out.println("inA.privateTest()");
}
protectedvoidprotectedTest(Objectobj)
{
System.out.println("inA.protectedTest(Object):"+obj);
}

protectedvoidprotectedTest(Stringstr)
{
System.out.println("inA.protectedTest(String):"+str);
}

publicstaticvoidmain(String[]args)
{
//TestA
Aa1=newA();
a1.privateTest();
//TestB
StringhelloStr="Hello";
ObjecthelloObj=helloStr;
Bb1=newB();
Aa2=b1;//這里發生了什么？困惑1
b1=a1;//編譯錯誤,困惑2
b1.privateTest();//編譯錯誤,困惑3
b1.protectedTest(helloObj);//輸出結果?困惑4
b1.protectedTest(helloStr);//編譯錯誤,困惑5
a2.protectedTest(helloObj);//輸出結果?困惑6
a2.protectedTest(helloStr);//輸出結果?困惑7?
}
}

下面,我來逐個解釋每一處困惑的地方:
困惑1：
這里其實就是子類自動上溯造型到父類A。這里a2其實是指向了一個B類型的對象.我們通常都可以這樣作:Aa2=b1,這樣作的意思實際上就是讓a2指向了一個類型B的對象—在這里就是b1了.
在java里面,關于跨類引用,有兩條規則應該記住:
1.如果a是類A的一個引用,那么,a可以指向類A的一個實例,或者說指向類A的一個子類.
2.如果a是接口A的一個引用,那么,a必須指向實現了接口A的一個類的實例.
所以,根據這兩個規則,我們就不難理解例子中的Aa2=b1是什么意思了.

困惑2:
Aa2=b1是可以的,但是為什么b1=a1卻是不行?在這里,我們依然可以套用上面的兩條規則,我們可以看到,b1是類B的一個引用,a1既不是類B的實例,也不是類B的子類的實例,所以直接b1=a1就出現了編譯錯誤.
如果確實需要進行這樣的轉化,我們可以這樣作:b1=(B)a1;進行強制轉化,也就是下溯造型.在java里面,上溯造型是自動進行的,但是下溯造型卻不是,需要我們自己定義強制進行.

困惑3:
b1.privateTest();編譯不通過?這是很顯然的,你可以回顧一下private的定義:私有域和方法只能被定義該域或方法的類訪問.所以,在這里,b1不能訪問A的方法privateTest(),即使b1是A的子類的實例.
請看下面的例子：
publicclassA
{
privateinttwo(inti){returni;}
}
classTestextendsA{
publicstaticvoidmain(String[]args){
System.out.println(A.two(3));
}
}

System.out.println(A.two(3));這行編譯出錯，顯然，因為private方法不能在這個類之外被訪問。

而protected則不同,我們回顧一下protected的定義:被保護的域或方法只能被類本身、類的子類和同一程序包中的類所訪問。
下面是一個錯誤使用protected的例子:
packagecn.org.matrix.test;
publicclassProtectedTest{
protectedvoidshow(){
System.out.println("Iaminprotectedmethod");
}
}

importcn.org.matrix.test.*;
publicclassTest{
publicstaticvoidmain(String[]args){
ProtectedTestobj=newProtectedTest();
obj.show();
}
}
因為訪問權限問題,你會得到”show()hasprotectedaccessintest.ProtectedTest”的出錯信息.


困惑4:
b1.protectedTest(helloObj);輸出的是”inB.protectedTest(Object):…”這到底是為什么呢?為什么jvm能夠確定是輸出B的方法而不是A的方法?這就和jvm的運行機制有關系了.我們上面提到了,a1是一個A類型的引用,但是指向了一個B類型的實例.在這里,如果jvm根據引用的類型-在這里就是A來定義調用哪個方法的話,那么應該是調用A的protectedTest(helloObj).
然后實際上不是這樣的,因為jvm的動態編譯能力,jvm會在run-time來決定調用哪一個method,而不是在compiletime.也就是所謂的late-binding(run-time)和early-binding(compile-time).

困惑5:
b1.protectedTest(helloStr);這里為什么會出現編譯錯誤?他可以調用類B的protectedTest(Objectobj)方法啊,把helloStr上溯造型成一個object就行了啊..或者上溯造型到A然后調用A的protectedTest(helloStr)方法啊.
呵呵,問題的根源就在于此了,既然有兩種選擇,jvm應該選擇那一種?這種不確定性如果交給jvm來動態決定的話,勢必帶來程序的不確定性..雖然java在其他的一些地方也有類似的情形出現,比如static變量的循環定義造成的不確定性,但是,在這里,jvm還是在編譯階段就解決了這個問題.
所以,我們會在這一步遇到編譯錯誤:“referencetoprotectedTestisambiguous;bothmethodprotectedTest(java.lang.String)inmytest.AandmethodprotectedTest(java.lang.Object)inmytest.Bmatchatline46.
在這里,我們遇到的是顯式的referenceambiguous錯誤,但是,有時候,隱式的referenceambiguous卻往往是更加的危險.
在這里,我舉個例子:
父類的源代碼:
publicsuper
{
privatevoidtest(inti,longj);
{
System.out.println(i+”and”+j);
}
}
子類的源代碼:
publicsub
{
privatevoidtest(longj,inti);
{
System.out.println(i+”and”+j);
}
}

子類和父類都用有相同名稱的方法test,參數類型不同而已.這種情況下,編譯可以被通過.
但是如果你在另外一個類中用到了如下代碼:
Subsb=newSub();
sb.test(100,3000);
你就會遇到編譯錯誤,因為沒有確定的指出3000的類型,所以造成referenceambiguous的錯誤了.

困惑6：
a2.protectedTest(helloObj);
輸出結果分別是：”inB.protectedTest(Object)..”經過上面的解釋，想必大家都能很清楚的知道為什么會有這兩個輸出結果了：a2.protectedTest(helloObj);因為jvm的late-binding，所以在run-time的時候，調用了B類的方法，雖然在編譯期間a2只是一個父類A的引用類型。

困惑7：
a2.protectedTest(helloStr);為什么這里會輸出”inA.protectedTest(Object)…”。為什么這里不會編譯出錯？為什么b1.protectedTest(helloStr)會出錯而a2.protectedTest(helloStr)會出錯？我調用了a2.equals(b1)和a2==b1得到的結果都是true啊？但是為什么這里出這個錯誤？
在這里，這個問題是最關鍵的，也是我們放到最后來解答的原因。
首先，回顧一下equals()和==的在java里面的概念，記得有一道scjp的題目：
題目：下面的哪些敘述為真。
A.equals()方法判定引用值是否指向同一對象。
B.==操作符判定兩個分立的對象的內容和類型是否一致。
C.equals()方法只有在兩個對象的內容一致時返回true。
D.類File重寫方法equals()在兩個分立的對象的內容和類型一致時返回true。
答案是AD,嚴格來說這個問題的答案是不確定的，因為equals()方法是可以被重載的，但是如果新類沒有重寫equals()，則該方法在兩個變量指向同一對象時返回真.實際上java也是推薦的是使用equals()方法來判斷兩個對象的內容是否一樣，就像String類的equals()方法所做的那樣，判定兩個String對象的內容是否相同。而==操作符返回true的唯一條件是兩個變量指向同一對象。
在這里，我們不再深入的討論關于equals()和==的區別和概念。我們只需要知道，在我們的例子里面，無論是equals()和==都是一個含義－就是引用值是否指向同一個對象(因為我們并沒有重寫equals()).
顯然，我們在進行了a2=b1.這一步之后，a2和b1都是指向同一個對象。
既然指向同一個對象，為什么還要區別對待a2和b1?為什么a2就沒有編譯錯誤，而b1就要遇到referenceambiguous錯誤？
我們現看看jvm規范里的一段話：
“TheJavaVirtualMachinedoesnotrequireanyparticularinternal
structureforobjects.InSun'scurrentimplementationoftheJavaVirtualMachine,areferencetoaclassinstanceisapointertoahandlethatisitselfapairofpointers:onetoatablecontainingthemethodsoftheobjectandapointertotheClassobjectthatrepresentsthetypeoftheobject,andtheothertothememoryallocatedfromtheJavaheapfortheobjectdata.”
實際上就是說：在java虛擬機中，類實例的引用就是指向一個句柄（handle）的指針，這個句柄是一對指針：一個指針指向一張表格，實際上這個表格也有兩個指針：一個指針指向一個包含了對象的方法表，另外一個指向類對象；另一個指針指向一塊從java堆中為分配出來內存空間。
那么，在a2＝b1的時候，到底發生了什么？
實際上，在a2=b1的時候，仍然是存在兩個句柄，a2和b1,但是a2和b1擁有同一塊數據內存塊和不同的函數表。所以在a2.protectedTest(helloStr)的時候，jvm會從a2的函數表里找到protectedTest(StringStr)方法，但是b1.protectedTest(helloStr)卻會出現編譯錯誤，因為jvm從b1的函數表里找不到，然后就選擇自己上溯造型還是參數上溯造型出現了ambiguous。這也是我們對這個問題的精確解釋。對這個問題的解釋到此結束了，如果大家想對這篇文章相關內容進行討論,可以到: http://blog.csdn.net/chensheng913/archive/2004/10/23/148309.aspx 發表意見.

引用,造型,protected和private的困惑