或许大家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 发表意见.
例子一共有两个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 发表意见.
