本文的目的只在于和诸位小虾们探讨(大虾们肯定已经搞定了这个问题,还请不吝赐教),因为这只是我个人的理解,没有看到有关的正式资料说明。
继承是OOP语言的必备功能,其功能强大,并且又是OO另一个重量级功能——多态——的基础,所以理解继承包括开发平台如何具体实现继承的机制至关重要。
对于java语言的继承机制本来没有想太多,因为教科书或语言规范都写的很清楚了,大概的:base class中的public和protected成员会被derived class自动接收,成为其成员。而base class中的private和包访问(默认访问级别)成员则不会被继承。你可以在derived class中直接使用继承到的成员或者覆写(override)它。
上面这句话理解起来不困难,但很多教科书(反正我一本都没看到)没有谈到在derived class中对继承的成员的两种不同操作——直接使用和覆写后再使用——jdk是如何实现的。不要小看这个问题,他很重要!
在《Think in Java,2nd edition》(侯捷中文版)的第六章有这么一个程序,源代码如下:
//: c06:Detergent.java
class Cleanser {
private String s = new String("Cleanser");
public void append(String a) { s += a; }
public void dilute() { append(" dilute()"); }
public void apply() { append(" apply()"); }
public void scrub() { append(" scrub()"); }
public void print() { System.out.println(s); }
public static void main(String[] args) {
Cleanser x = new Cleanser();
x.dilute(); x.apply(); x.scrub();
x.print();
}
}
public class Detergent extends Cleanser {
// Change a method:
public void scrub() {
append(" Detergent.scrub()");
super.scrub(); // Call base-class version
}
// Add methods to the interface:
public void foam() { append(" foam()"); }
// Test the new class:
public static void main(String[] args) {
Detergent x = new Detergent();
x.dilute();
x.apply();
x.scrub();
x.foam();
x.print();
System.out.println("Testing base class:");
Cleanser.main(args);
}
} ///:~
这里面,Cleanser类中有一个private实例变量s,五个普通public方法,和一个main()方法。根据规范,除了private实例变量s外,五个普通方法和那个mian()方法都会被Detergent类继承。再来看Detergent类,Detergent类中新添了一个方法foam(),另外有两个继承的方法被覆写了,一个是scrub()方法,还有一个,千万要注意,继承自Cleanser类的main()方法也被覆写了!不信你可以试验下,注释掉Detergent类中的mian()方法,编译后用java Detergent执行,照样可以,说明main()方法被继承下来了,不过我又用自己的main()方法覆写了它,这样我就可以执行自己的代码了。
仔细观察上述代码,不要先用jdk执行它,而是在脑子里想它的执行过程,你会发现,当我们在Detergent的实例中调用直接继承的方法,如dilute(), apply()时,他们要调用append()方法,OK没问题,append()方法也是public的,已经被继承了,调用自己的方法这很天经地义,思考上没什么障碍,但,问题出现了,append()方法的实现是要使用String s,而s是Cleancer的private成员,按规定它是不能被继承的,也就是说在Detergent实例里面根本就没有s这个变量!
可是,程序是可以编译执行的,没有任何问题。那么问题当然出在我们自己,是我们没有彻底理解jdk对java继承的实现机制!
经过反复琢磨,反复修改,写测试代码,总算对这个问题有了个比较深入的了解,请大家先看我的结论:jdk把derived class编译成字节代码时,对直接继承和覆写实现的成员,操作是不同的!对于直接继承的成员,并不把其代码加到derived class的代码中,但会保留一个引用(我不知道,我自己的理解和设想),用来指向base class中相应的成员;而对于被覆写过的成员来说,则象对待derived class中的其他自有成员一样,在分配空间是给他们分配自己的空间,也就是说,在编译后的字节代码中会有这些成员的代码。
所以,上面的问题就可以解决了。先看看上面的程序执行后的结果:
Cleanser dilute() apply() Detergent.scrub() scrub() foam()
Testing base class:
Cleanser dilute() apply() scrub()
注意,一定要这样执行:java Detergent,因为Cleanser也有main()方法,你用java Cleanser,也是能执行的,但那只能执行Cleanser类了。
这个程序在进行一系列动作之后分别打印了两次String s的值。第一次是用Detergent类的实例的print()方法打印的,第二次是用Cleanser类的实例的print()方法打印的。对于打印的对象s来说,她只有一个,属于Cleanser类,那为什么Detergent类的方法也能访问到s呢?根据我上面的结论,因为print()方法是直接继承来的,在Detergent类中没有覆写它(也就是说没有把它明示的写出来),所以,这个方法只保留一份,在Cleanser类中,不过,由于Detergent类是Cleanser类的派生类,所以,在Detergent类中有个引用可以让它访问Cleanser类的print()方法,并且在使用的时候就好像使用自己的方法一样。而执行的时候,其实真正的执行都是在Cleanser类的空间里执行的,只不过执行完后把结果返回到Detergent类中而已!所以,因为真正的执行是在Cleanser类的实例中执行的,那么String s就当然可以被访问到啦,所以,结果中的第一行(在Detergent中打印s的内容)的结果其实是Cleanser中的s内容,至于为什么在Cleanser中打印s却不一样?呵呵,这很简单,因为之前新生成了一个Cleanser实例,不一样的实例,数据当然不一样,不信,你在源代码的最后再添一行:x.print();
结果保证是:
Cleanser dilute() apply() Detergent.scrub() scrub() foam()
Testing base class:
Cleanser dilute() apply() scrub()
Cleanser dilute() apply() Detergent.scrub() scrub() foam()
至此,jdk对java继承的实现机制我已经有了自己的理解了,我认为它就是正确的,你认为呢?
摘自:http://topic.csdn.net/t/20040313/00/2838683.html
针对上面这篇转的文章,我几乎接受所有的观点,只是在文章开头讲到:
base class中的public和protected成员会被derived class自动接收,成为其成员。而base class中的private和包访问(默认访问级别)成员则不会被继承。
这个地方我有不同意见,那就是:包访问成员也能继承,就是在程序中,前面什么修饰符都没有,String s =null;类似这样的情况,这个变量s是可以被继承的。
继承是OOP语言的必备功能,其功能强大,并且又是OO另一个重量级功能——多态——的基础,所以理解继承包括开发平台如何具体实现继承的机制至关重要。
对于java语言的继承机制本来没有想太多,因为教科书或语言规范都写的很清楚了,大概的:base class中的public和protected成员会被derived class自动接收,成为其成员。而base class中的private和包访问(默认访问级别)成员则不会被继承。你可以在derived class中直接使用继承到的成员或者覆写(override)它。
上面这句话理解起来不困难,但很多教科书(反正我一本都没看到)没有谈到在derived class中对继承的成员的两种不同操作——直接使用和覆写后再使用——jdk是如何实现的。不要小看这个问题,他很重要!
在《Think in Java,2nd edition》(侯捷中文版)的第六章有这么一个程序,源代码如下:
//: c06:Detergent.java
class Cleanser {
private String s = new String("Cleanser");
public void append(String a) { s += a; }
public void dilute() { append(" dilute()"); }
public void apply() { append(" apply()"); }
public void scrub() { append(" scrub()"); }
public void print() { System.out.println(s); }
public static void main(String[] args) {
Cleanser x = new Cleanser();
x.dilute(); x.apply(); x.scrub();
x.print();
}
}
public class Detergent extends Cleanser {
// Change a method:
public void scrub() {
append(" Detergent.scrub()");
super.scrub(); // Call base-class version
}
// Add methods to the interface:
public void foam() { append(" foam()"); }
// Test the new class:
public static void main(String[] args) {
Detergent x = new Detergent();
x.dilute();
x.apply();
x.scrub();
x.foam();
x.print();
System.out.println("Testing base class:");
Cleanser.main(args);
}
} ///:~
这里面,Cleanser类中有一个private实例变量s,五个普通public方法,和一个main()方法。根据规范,除了private实例变量s外,五个普通方法和那个mian()方法都会被Detergent类继承。再来看Detergent类,Detergent类中新添了一个方法foam(),另外有两个继承的方法被覆写了,一个是scrub()方法,还有一个,千万要注意,继承自Cleanser类的main()方法也被覆写了!不信你可以试验下,注释掉Detergent类中的mian()方法,编译后用java Detergent执行,照样可以,说明main()方法被继承下来了,不过我又用自己的main()方法覆写了它,这样我就可以执行自己的代码了。
仔细观察上述代码,不要先用jdk执行它,而是在脑子里想它的执行过程,你会发现,当我们在Detergent的实例中调用直接继承的方法,如dilute(), apply()时,他们要调用append()方法,OK没问题,append()方法也是public的,已经被继承了,调用自己的方法这很天经地义,思考上没什么障碍,但,问题出现了,append()方法的实现是要使用String s,而s是Cleancer的private成员,按规定它是不能被继承的,也就是说在Detergent实例里面根本就没有s这个变量!
可是,程序是可以编译执行的,没有任何问题。那么问题当然出在我们自己,是我们没有彻底理解jdk对java继承的实现机制!
经过反复琢磨,反复修改,写测试代码,总算对这个问题有了个比较深入的了解,请大家先看我的结论:jdk把derived class编译成字节代码时,对直接继承和覆写实现的成员,操作是不同的!对于直接继承的成员,并不把其代码加到derived class的代码中,但会保留一个引用(我不知道,我自己的理解和设想),用来指向base class中相应的成员;而对于被覆写过的成员来说,则象对待derived class中的其他自有成员一样,在分配空间是给他们分配自己的空间,也就是说,在编译后的字节代码中会有这些成员的代码。
所以,上面的问题就可以解决了。先看看上面的程序执行后的结果:
Cleanser dilute() apply() Detergent.scrub() scrub() foam()
Testing base class:
Cleanser dilute() apply() scrub()
注意,一定要这样执行:java Detergent,因为Cleanser也有main()方法,你用java Cleanser,也是能执行的,但那只能执行Cleanser类了。
这个程序在进行一系列动作之后分别打印了两次String s的值。第一次是用Detergent类的实例的print()方法打印的,第二次是用Cleanser类的实例的print()方法打印的。对于打印的对象s来说,她只有一个,属于Cleanser类,那为什么Detergent类的方法也能访问到s呢?根据我上面的结论,因为print()方法是直接继承来的,在Detergent类中没有覆写它(也就是说没有把它明示的写出来),所以,这个方法只保留一份,在Cleanser类中,不过,由于Detergent类是Cleanser类的派生类,所以,在Detergent类中有个引用可以让它访问Cleanser类的print()方法,并且在使用的时候就好像使用自己的方法一样。而执行的时候,其实真正的执行都是在Cleanser类的空间里执行的,只不过执行完后把结果返回到Detergent类中而已!所以,因为真正的执行是在Cleanser类的实例中执行的,那么String s就当然可以被访问到啦,所以,结果中的第一行(在Detergent中打印s的内容)的结果其实是Cleanser中的s内容,至于为什么在Cleanser中打印s却不一样?呵呵,这很简单,因为之前新生成了一个Cleanser实例,不一样的实例,数据当然不一样,不信,你在源代码的最后再添一行:x.print();
结果保证是:
Cleanser dilute() apply() Detergent.scrub() scrub() foam()
Testing base class:
Cleanser dilute() apply() scrub()
Cleanser dilute() apply() Detergent.scrub() scrub() foam()
至此,jdk对java继承的实现机制我已经有了自己的理解了,我认为它就是正确的,你认为呢?
摘自:http://topic.csdn.net/t/20040313/00/2838683.html
针对上面这篇转的文章,我几乎接受所有的观点,只是在文章开头讲到:
base class中的public和protected成员会被derived class自动接收,成为其成员。而base class中的private和包访问(默认访问级别)成员则不会被继承。
这个地方我有不同意见,那就是:包访问成员也能继承,就是在程序中,前面什么修饰符都没有,String s =null;类似这样的情况,这个变量s是可以被继承的。