父类中有两个方法a和b，子类继承父类，子类复写放法a。现在new子类赋予父类，求改计算顺序？是先等父类计算完了，在计算子类中的，复写的在子类中计算，即先b再a，不太懂

875588381 发表于 2014-5-23 14:15
方法的调用顺序你看清楚了吗？
首先调用子类的构造方法，但是此时已经跳转到了父类的构造方法中了。
父类 ...

哦，好吧，谢谢啊

曹强 发表于 2014-5-23 10:25
那为什么不先输出C，而是先输出B呢，带参数的构造器在不带参数的构造器上面啊 ...

方法的调用顺序你看清楚了吗？
首先调用子类的构造方法，但是此时已经跳转到了父类的构造方法中了。
父类的构造方法结束后，才会返回到子类的构造方法中。

875588381 发表于 2014-5-23 08:06
你好同学，具体解释我都写在了注释中，希望对你有所帮助。

那为什么不先输出C，而是先输出B呢，带参数的构造器在不带参数的构造器上面啊

你好同学，具体解释我都写在了注释中，希望对你有所帮助。:)

1. class Super
   
2. {
   
3.         int i = 0;
   
4.         public Super(String a) { //带有参数的构造器
   
5.                 System.out.println("A");
   
6.                 i = 1;
   
7.         }
   
8.         public Super() { //不带参数的构造器
   
9.                 System.out.println("B");
   
10.                 i = i + 2;
    
11.         }
    
12. }
    
13. 
    
14. class Demo extends Super
    
15. {
    
16.         public Demo(String a) { //子类的构造器，
    
17.                 /*
    
18.                         当调用这个构造器的时候，首先会执行什么呢？
    
19.                         答案是super();
    
20.                         也就是说，会去调用Super类的无参数的构造器，
    
21.                         此时会先输出B,然后i = 0 + 2 = 2;
    
22.                         之后执行本构造器中的输出语句，输出C
    
23.                         之后i赋值为5，
    
24.                         最后main()方法中调用d.i，输出为5.
    
25.                 */
    
26.                 //super(); 这句代码是编译器隐含的，如果不写，编译器会自动生成。
    
27.                 System.out.println("C");
    
28.                 i = 5;
    
29.         }
    
30.         public static void main(String[] args)
    
31.         {
    
32.                 int i = 4;  //局部变量i，只在main()方法的作用域有效
    
33.                 Super d = new Demo("A"); //父类引用指向子类对象
    
34.                 System.out.println(d.i);
    
35.         }
    
36. }
    

复制代码

875588381 发表于 2014-5-21 18:00
额，同学，最好将代码贴上来，看纯文字描述很头疼的。

1. class Super{
   
2.      int i=0;
   
3.      public Super(String a){
   
4.           s.o.p("A");
   
5.           i=1;
   
6.      }
   
7.      public Super{
   
8.            s.o.p("B");
   
9.            i+=2；
   
10.      }
    
11. }
    
12. class Demo extends Super{
    
13.      public Demo(String a){
    
14.              s.o.p("C");
    
15.              i=5;
    
16.       }
    
17.        public static void main (String[] args){
    
18.        int i=4;
    
19.        Super d=new Demo ("A");
    
20.       s.o.p(d.i);
    
21.       }
    
22. }

复制代码

通过一段程序说明：

1. class Person {
   
2.         public void eat(){
   
3.                 System.out.println("吃饭");
   
4.         }
   
5.         public void sleep(){
   
6.                 System.out.println("睡觉");
   
7.         }
   
8. }
   
9. class Girl extends Person {
   
10.         public void eat(){
    
11.                 System.out.println("女生吃饭");
    
12.         }
    
13. }
    
14. 
    
15. class DuoTaiDemo {
    
16.         public static void main(String[] args){
    
17. 
    
18.                 Person g = new Girl();
    
19.                 g.eat();
    
20.         }
    
21. }

复制代码

       通过以上代码，我们先进行分析，这涉及到常量池的问题（对常量池不做解释）。
      Girl.eat(); 子类重写父类方法，被重写的方法在子类跟父类的方法表中索引相同。
　　调用的时候，在父类类型的方法表中查找eat方法的索引，然后把索引存到DuoTaiDemo类的常量表中(常量池解析，就是用Person类方法表中的索引项来代替常量池中的符号引用)。
　　因为索引相同，直接拿常量表中eat方法的索引去子类方法表中调用eat()方法。 所以，此时调用的是被子类重写的方法。
      所以，对此，可知，创建的多态对象只调用父类中的a方法，而不调用b方法，但是，调用的a方法是子类重写的a方法。

对于这种多态的情况，远行时是看等号的右边对象类型！

上代码.................................

额，同学，最好将代码贴上来，看纯文字描述很头疼的。