一道关于this和super的面试题

[lynn_chen]

昨天下午去面试的时候遇到一道题，大家看看。

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

大家来讨论下，这是什么原因？

[lh_fengyuzhe]

学习了

[飞跃颠峰]

说下我个人的理解，实例化某个对象的过程中，实例到底是产生了一个还是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实例，所以通过它能访问被重写前的方法。

[lynn_chen]

[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).

[lynn_chen]

[Quote=引用 28 楼 alexandertech 的回复:]

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

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

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

谢谢 alexandertech！

[lynn_chen]

[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]

[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

[若鱼1919]

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

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

老祖宗那里就明确说了：孩子们，你们听着，getClass()这个方法你们都可以调用，但是谁也不能给我覆盖掉。你们也没有必要覆盖，到底是哪个儿子还是孙子调用的，运行时，老祖宗我心里明镜似的，肯定会返回给你实际的类型的。

[飞跃颠峰]

15楼说得很生动阿。

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

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

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

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

[lynn_chen]

[Quote=引用 7 楼 alexandertech 的回复:]

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

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

[lynn_chen]

[Quote=引用 9 楼 qybao 的回复:]

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

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

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

子类show()方法
 
void show() {
        super.show();
        System.out.println(super.getClass().getName());
    }

这个super引用的还是子类的实例，那这个方法会进入死循环。

[飞跃颠峰]

[Quote=引用 17 楼 snakewarhead 的回复:]

引用 7 楼 alexandertech 的回复:

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


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

super返回一个逻辑上被视为父类的实例，目的是让你能通过它访问父类中被重写的方法或被隐藏的字段。
至于getClass方法，从未被重写，所以你用不用super返回的结果都是一样的。

[lynn_chen]

[Quote=引用 16 楼 alexandertech 的回复:]

15楼说得很生动阿。

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

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

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

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

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

[lynn_chen]

[Quote=引用 19 楼 alexandertech 的回复:]

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

super实际上引用的是什么？
我的基础确实还很不扎实，麻烦在说一下！

[lynn_chen]

[Quote=引用 15 楼 goldenfish1919 的回复:]

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


你的SubClass类里面定义getClass()了没？没有吧！
那这个getClass()是哪里的呢？当然是……
[/Quote]
你没懂我意思，我是说：
super引用的是父类的实例，this引用的是当前自身的实例。
他们getClass()，当然是返回各自的实例！

[oO临时工Oo]

[Quote=引用 20 楼 snakewarhead 的回复:]
引用 16 楼 alexandertech 的回复:

15楼说得很生动阿。

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

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

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

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


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

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

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

[qybao]

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

SuperClass sc = new SubClass();
System.out.println(sc.getClass());
SuperClass sc2 = (SupperClass)sc; //强行转换为父类，看看有没有效果？
System.out.println(sc2.getClass());

[lynn_chen]

[Quote=引用 23 楼 trocp 的回复:]
实例有N个，每创建一个类就有一个Objet的实例。

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

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

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

所以还是回到老问题：super到底引用的是什么？

[rockyou666]

我同意7搂的说法啊！

[oO临时工Oo]

肯定引用的是父类的资源，但这个分两个情况：
假如有这样一个实例：

	class Father extends Object{
		//......
	}
	class Son extends Father{
		//......
	}

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

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

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

[lynn_chen]

算了，结贴！
谢谢各位！