一道关于this和super的面试题

lynn_chen 2011-06-14 12:29:17
昨天下午去面试的时候遇到一道题,大家看看。
class SuperClass {
SuperClass() throws Exception {
System.out.println(this.getClass().getName());
}
void show() {
System.out.println(super.getClass().getName());
show2();
}
void show2() {}
}




public class SubClass extends SuperClass {
SubClass() throws Exception {}
void show() {
super.show();
System.out.println(super.getClass().getName());
}

void show2() {
System.out.println(super.getClass().getSuperclass().getName());
}

public static void main(String args[]) throws Exception {
SuperClass s = new SubClass();
s.show();
}
}



先自己做一下,然后再debug看看。

我写的答案是:
SuperClass
Object
SuperClass

我理解的运行流程是:

1. SuperClass s = new SubClass();
首先主线程进入main,此时加载两个.class文件进方法区,当new SubClass()时,在堆区实例化这两个类,依次调用SuperClass()和SubClass()(还有Object)。

(SuperClass)
SuperClass() throws Exception {
System.out.println(this.getClass().getName());
}

这个this应该是父类的实例啊?(没搞懂!)
打印结果是:SuperClass

2. s.show();
应用变量s引用的是SubClass的实例,s.show调用的是子类的覆盖方法show(),

(SubClass)
void show() {
super.show();
System.out.println(super.getClass().getName());
}

进入方法后,压入方法栈,运行super.show()父类实例的show()方法:

(SuperClass)
void show() {
System.out.println(super.getClass().getName());
show2();
}

这个super又应该是SuperClass的父类实例(Object的实例)。
打印结果是:Object

然后show2(),这个应该是父类的实例的方法,是个空方法,所以什么都不打印。

最后出栈,运行(SubClass.show()的第2个语句)
System.out.println(super.getClass().getName());
打印结果是:SuperClass

实际的运行结果是:

SubClass
SubClass
SuperClass
SubClass

大家来讨论下,这是什么原因?
...全文
251 点赞 收藏 30
写回复
30 条回复
lynn_chen 2011年06月15日
算了,结贴!
谢谢各位!
回复 点赞
oO临时工Oo 2011年06月15日
肯定引用的是父类的资源,但这个分两个情况:
假如有这样一个实例:
	class Father extends Object{
//......
}
class Son extends Father{
//......
}


当在Son中通过Super()引用父亲类的构造方法时,Super表示是就是父类Father

当在Son中通过super引用 Father的资源(标记为资源F),资源F分且只分为两种:
一种是Father自己的;
一种是Father他父类Object的,当Father的父类不是Object时,依次类推.

所以可以这样理解为Son通过Super引用其父类(包括父类的父类....)的资源



回复 点赞
rockyou666 2011年06月15日
我同意7搂的说法啊!
回复 点赞
lynn_chen 2011年06月15日
[Quote=引用 23 楼 trocp 的回复:]
实例有N个,每创建一个类就有一个Objet的实例。

但是这个实例与运行时类是有区别的。Object的getClass()方法返回的是运行时类,不是实例。JDK源代码中Object.getClass()就是这么解释的。

[/Quote]
你说那个帖子我看了下,意思都差不多。

Object的getClass()方法返回的是运行时类”这个细节我还没注意到,
也就是对应类的class对象,父类在产生实例时会伴随着产生他对应的class对象。

所以还是回到老问题:super到底引用的是什么?
回复 点赞
qybao 2011年06月15日
其实很简单
LZ只要能理解以下的代码,就能理解问题的结果了

SuperClass sc = new SubClass();
System.out.println(sc.getClass());
SuperClass sc2 = (SupperClass)sc; //强行转换为父类,看看有没有效果?
System.out.println(sc2.getClass());
回复 点赞
oO临时工Oo 2011年06月15日
[Quote=引用 20 楼 snakewarhead 的回复:]
引用 16 楼 alexandertech 的回复:

15楼说得很生动阿。

另外我看楼主可能有一点有误解,

创建子类的实例过程中,不管它层层调用了多少个父类的构造方法,实例永远只有一个。

这个实例在逻辑上同时是父类和子类的实例,但是如果拿个显微镜来看,归根到底是子类的实例。

有点象量子力学里面粒子的不确定性,但当观察者注入,波函数坍塌一样。


实例怎么会只有一……
[/Quote]

实例有N个,每创建一个类就有一个Objet的实例。

但是这个实例与运行时类是有区别的。Object的getClass()方法返回的是运行时类,不是实例。JDK源代码中Object.getClass()就是这么解释的。

回复 点赞
lynn_chen 2011年06月15日
[Quote=引用 15 楼 goldenfish1919 的回复:]

引用 13 楼 snakewarhead 的回复:
我先承认我的基础很差,
super引用的是父类的实例,this引用的是当前自身的实例。
在同一类中,super.getClass()怎么会等价于this.getClass().
而且跟是不是final方法没有关系。


你的SubClass类里面定义getClass()了没?没有吧!
那这个getClass()是哪里的呢?当然是……
[/Quote]
你没懂我意思,我是说:
super引用的是父类的实例,this引用的是当前自身的实例。
他们getClass(),当然是返回各自的实例!
回复 点赞
lynn_chen 2011年06月15日
[Quote=引用 19 楼 alexandertech 的回复:]

super返回一个逻辑上被视为父类的实例,目的是让你能通过它……
[/Quote]

super实际上引用的是什么?
我的基础确实还很不扎实,麻烦在说一下!
回复 点赞
lynn_chen 2011年06月15日
[Quote=引用 16 楼 alexandertech 的回复:]

15楼说得很生动阿。

另外我看楼主可能有一点有误解,

创建子类的实例过程中,不管它层层调用了多少个父类的构造方法,实例永远只有一个。

这个实例在逻辑上同时是父类和子类的实例,但是如果拿个显微镜来看,归根到底是子类的实例。

有点象量子力学里面粒子的不确定性,但当观察者注入,波函数坍塌一样。
[/Quote]

实例怎么会只有一个?
think in java(P129) 上说是:当创建一个导出类时,该对象包含了一个基类的子对象。
在创建子类实例时,会依次创建父类的实例,那不然父类public的成员变量子类是如何访问的。

回复 点赞
飞跃颠峰 2011年06月15日
[Quote=引用 17 楼 snakewarhead 的回复:]

引用 7 楼 alexandertech 的回复:

对象s是一个SubClass的实例,
getClass()永远是返回实例的实际Class,所以s.super.getClass仍然返回SubClass


s.super.getClass 是什么意思?
[/Quote]

super返回一个逻辑上被视为父类的实例,目的是让你能通过它访问父类中被重写的方法或被隐藏的字段。
至于getClass方法,从未被重写,所以你用不用super返回的结果都是一样的。
回复 点赞
lynn_chen 2011年06月15日
[Quote=引用 9 楼 qybao 的回复:]

其实很简单
LZ只要能理解以下的代码,就能理解问题的结果了

SuperClass sc2 = (SupperClass)sc; //强行转换为父类,看看有没有效果?

[/Quote]
你的意思是说:
super是子类向上转型的父类代表的引用变量吗?

子类show()方法

void show() {
super.show();
System.out.println(super.getClass().getName());
}

这个super引用的还是子类的实例,那这个方法会进入死循环。
回复 点赞
lynn_chen 2011年06月15日
[Quote=引用 7 楼 alexandertech 的回复:]

对象s是一个SubClass的实例,
getClass()永远是返回实例的实际Class,所以s.super.getClass仍然返回SubClass

[/Quote]
s.super.getClass 是什么意思?
回复 点赞
飞跃颠峰 2011年06月15日
15楼说得很生动阿。

另外我看楼主可能有一点有误解,

创建子类的实例过程中,不管它层层调用了多少个父类的构造方法,实例永远只有一个。

这个实例在逻辑上同时是父类和子类的实例,但是如果拿个显微镜来看,归根到底是子类的实例。

有点象量子力学里面粒子的不确定性,但当观察者注入,波函数坍塌一样。
回复 点赞
若鱼1919 2011年06月15日
[Quote=引用 13 楼 snakewarhead 的回复:]
我先承认我的基础很差,
super引用的是父类的实例,this引用的是当前自身的实例。
在同一类中,super.getClass()怎么会等价于this.getClass().
而且跟是不是final方法没有关系。
[/Quote]

你的SubClass类里面定义getClass()了没?没有吧!
那这个getClass()是哪里的呢?当然是继承来的!
从那里继承来的呢?从老祖宗Object继承来的。

老祖宗那里就明确说了:孩子们,你们听着,getClass()这个方法你们都可以调用,但是谁也不能给我覆盖掉。你们也没有必要覆盖,到底是哪个儿子还是孙子调用的,运行时,老祖宗我心里明镜似的,肯定会返回给你实际的类型的。
回复 点赞
lynn_chen 2011年06月15日
[Quote=引用 4 楼 hulujava111 的回复:]

1:SubClass //new SubClass()自动调用父类的无参数构造函数,this.getClass().getName(),这里的this还是指向new出来的那个子类实例

[/Quote]

为什么这个this引用的是SubClass的实例?
new SubClass()自动调用父类的无参数构造函数来创建父类的实例(think in java 上说是:当创建一个导出类时,该对象包含了一个基类的子对象),


父类的构造方法:
SuperClass() throws Exception {
System.out.println(this.getClass().getName());
}

这个this在父类构造器中,父类会根据方法区的class字节段在堆区生成字节块用以代表父类的实例,然后初始化成员变量后调用构造器,而此时的this.getClass()怎么不是the runtime class of SuperClass
回复 点赞
lynn_chen 2011年06月15日
[Quote=引用 1 楼 goldenfish1919 的回复:]

getClass()是定义在Object中的final方法,因此,子类是无法覆盖getClass()方法的。
因此,super.getClass()等价于this.getClass().
jdk文档里面说:
The Class object that represents the runtime class of this object.
返回的是运行时的实际类型。
[/Quote]

我先承认我的基础很差,
super引用的是父类的实例,this引用的是当前自身的实例。
在同一类中,super.getClass()怎么会等价于this.getClass().
而且跟是不是final方法没有关系。
回复 点赞
lynn_chen 2011年06月15日
[Quote=引用 28 楼 alexandertech 的回复:]

说下我个人的理解,实例化某个对象的过程中,实例到底是产生了一个还是N个这主要是个语言表达的问题。

Java文档中对实例没有很严格的定义,相关的主要有实例变量和一个运算符instanceof。(如有遗漏,欢迎补充)

从实例变量的角度来说,每个对象实例化后拥有自身与父亲类的所有实例变量,但只有一份拷贝。如果B继承了A类,A类定义了变量x, b = new B(); b.x和b.super……
[/Quote]

谢谢 alexandertech!
回复 点赞
lynn_chen 2011年06月15日
[Quote=引用 28 楼 alexandertech 的回复:]

从实例变量的角度来说,每个对象实例化后拥有自身与父亲类的所有实例变量,但只有一份拷贝.
[/Quote]

恩,这句话没说错!

我查阅了一下JDK Documentation,上面对this和super也没作详细的解释。
只是说super是关键字,及他的3个作用:
use the super keyword to invoke a superclass's constructor.
you can invoke the overridden method through the use of the keyword super.
You can also use super to refer to a hidden field (although hiding fields is discouraged).
回复 点赞
飞跃颠峰 2011年06月15日
说下我个人的理解,实例化某个对象的过程中,实例到底是产生了一个还是N个这主要是个语言表达的问题。

Java文档中对实例没有很严格的定义,相关的主要有实例变量和一个运算符instanceof。(如有遗漏,欢迎补充)

从实例变量的角度来说,每个对象实例化后拥有自身与父亲类的所有实例变量,但只有一份拷贝。如果B继承了A类,A类定义了变量x, b = new B(); b.x和b.super.x指向内存中同一个数据拷贝。 从这个角度来说,我觉得把它理解为只有一个实例更自然。

从instanceof来说,如果B继承了A类, b = new B(); b instanceof B 和 b instanceof A 都返回true,就是说b既是B的实例,也是A的实例。这样同样把它理解为只有一个实例更自然。否则就应当是(b instanceof A) == false && (b.super.instanceof A) == true了。

我觉得这样就比较好理解b.super.getClass()了,可以理解成b和b.super指向同一个实例,因为getClass()不曾被重写,指向同一个拷贝,所以返回结果相同,即所谓运行时类。对于被重写过的方法,因为b.super指向一个逻辑上的A实例,所以通过它能访问被重写前的方法。



回复 点赞
lh_fengyuzhe 2011年06月15日
学习了
回复 点赞
发动态
发帖子
Java SE
创建于2007-09-28

3.4w+

社区成员

30.7w+

社区内容

Java 2 Standard Edition
社区公告
暂无公告