谁来帮我讲解一下这道题~~~谢谢

Question

10. class One {
11. public One() { System.out.print(1); }
12. }
13. class Two extends One {
14. public Two() { System.out.print(2); }
15. }
16. class Three extends Two {
17. public Three() { System.out.print(3); }
18. }
19. public class Numbers{
20. public static void main( String[] argv) { new Three(); }
21. }
What is the result when this code is executed?
A. 1
B. 3
C. 123
D. 321
E. The code rims with no output.
Answer: C  帮忙讲讲这道题的编译过程~~为什么是123的顺序输出~谢谢~~~

Answer 1

java虚拟机不是从最特殊的类开始依次向其父类找方法吗？？
    为什么不是321的输出呢？？？

Answer 2

谢谢LS各位~~再来看看这段代码
public class Test {
public static void main( String[] args) { 
    m(new GraduateStudent());
    m(new Student());
    m(new Person());
  }
  public static void m(Object x){
   System.out.println(x.toString());
   }
  }
  class GraduateStudent extends Student { 
   }
 
class Student extends Person {
 public String toString() { 
    return "Student" ;
    }
 }
 class  Person extends Object {
 public String toString() { 
  return "Person";
 }
这个是用静态方法直接调用~~没有构造实例~~~这个java虚拟机就直接从子类开始找匹配的方法~依次向父类，
    直到找到位置，一旦找一个实现就会停止和查找和实现  能说说这者之间的区别吗？？？？我有点弄糊涂了

Answer 3

package mypack;class One {
public One() {
super();  //默认添加了父类的无参构造器,必须是在第一句
System.out.print(1);
}
}class Two extends One {
public Two() {
super();  //默认添加了父类的无参构造器,必须是在第一句
System.out.print(2);
}
}class Three extends Two {
public Three() {
super();  //默认添加了父类的无参构造器,必须是在第一句
System.out.print(3);
}
}public class Numbers {
public static void main(String[] argv) {
new Three();  //所以这里会分别调用Object(),One(),Two(),Three()构造器
}
}

Answer 4

你不是已经创建了？构造实例。    m(new GraduateStudent());
    m(new Student());
    m(new Person());

Answer 5

但是创建 new GraduateStudent())的时候 Student()和Person()还没存在呀？

Answer 6

创建GraduateStudent对象的时候不需要同时创建student对象，person对象。

Answer 7

package mypack;public class Test {
public static void main(String[] args) {
m(new GraduateStudent());
m(new Student());
m(new Person());
} public static void m(Object x) {
System.out.println(x.toString());
}
}class GraduateStudent extends Student {  //继承Student,拥有的是Student重写的toString()方法
}class Student extends Person {
public String toString() {    //这里重写了toString()方法,Student拥有这方法
return "Student";
}
}class Person extends Object {    //这里重写了toString()方法,Person拥有这方法
public String toString() {
return "Person";
}
}
这个是用静态方法直接调用~~没有构造实例~~~这个java虚拟机就直接从子类开始找匹配的方法~依次向父类， 
    直到找到位置，一旦找一个实现就会停止和查找和实现   能说说这者之间的区别吗？？？？我有点弄糊涂了.
答:本人理解是类调用的自己拥有的toString()方法,它继承到哪个就是哪个.并不是楼主所说的从子类向上找.

Answer 8

根据jvm的执行规则，对于代码：
public class Test {
    public static void main( String[] args) { 
    m(new GraduateStudent());
    m(new Student());
    m(new Person());
  }
  public static void m(Object x){
      System.out.println(x.toString());
      }
  }
  class GraduateStudent extends Student { 
   }
 
class Student extends Person {
 public String toString() { 
    return "Student" ;
    }
 }
 class  Person extends Object {
 public String toString() { 
  return "Person";
 }
}静态方法m调用的是参数对象x的toString()方法，由多态的调用规则，调用的方法由调用的对象决定(而不是引用的类型)，因此
m(new GraduateStudent())试图调用class GraduateStudent extends Student中的toString()方法，但是该类中没有定义toString()方法，所以jvm只能向上寻找其基类class Student extends Person，然后找到了toString()方法，于是显示Student。
同理，m(new Student());也调用Student类的toString方法，显示Student.
而m(new Person());调用Person类的toString方法，显示Person.强调一个概念：
语句
Object x = new Person();
的意思是用Object类型的引用(reference)引用一个Person类型的对象，其中x的成员方法toString是由Person决定的，而不是Object。这个是多态的执行规则。跟静态不静态没有关系。