黑马程序员技术交流社区

标题: 关于子父类运算顺序的 [打印本页]
作者: 曹强    时间: 2014-5-21 14:05
标题: 关于子父类运算顺序的
本帖最后由 曹强 于 2014-5-24 14:03 编辑

父类中有两个方法a和b，子类继承父类，子类复写放法a。现在new子类赋予父类，求改计算顺序？是先等父类计算完了，在计算子类中的，复写的在子类中计算，即先b再a，不太懂
作者: 875588381    时间: 2014-5-21 18:00
额，同学，最好将代码贴上来，看纯文字描述很头疼的。
作者: wuhyoung    时间: 2014-5-21 19:22
上代码.................................
作者: 喜爱    时间: 2014-5-21 20:02
对于这种多态的情况，远行时是看等号的右边对象类型！
作者: hamiguadjs    时间: 2014-5-22 01:08
通过一段程序说明：
  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. }

  15. class DuoTaiDemo {
  16.         public static void main(String[] args){

  18.                 Person g = new Girl();
  19.                 g.eat();
  20.         }
  21. }
复制代码

       通过以上代码，我们先进行分析，这涉及到常量池的问题（对常量池不做解释）。
      Girl.eat(); 子类重写父类方法，被重写的方法在子类跟父类的方法表中索引相同。
　　调用的时候，在父类类型的方法表中查找eat方法的索引，然后把索引存到DuoTaiDemo类的常量表中(常量池解析，就是用Person类方法表中的索引项来代替常量池中的符号引用)。
　　因为索引相同，直接拿常量表中eat方法的索引去子类方法表中调用eat()方法。 所以，此时调用的是被子类重写的方法。
      所以，对此，可知，创建的多态对象只调用父类中的a方法，而不调用b方法，但是，调用的a方法是子类重写的a方法。
作者: 曹强    时间: 2014-5-23 07:02
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. }
复制代码
作者: 875588381    时间: 2014-5-23 08:06
你好同学，具体解释我都写在了注释中，希望对你有所帮助。:)

  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. }

  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. }
复制代码

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

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

方法的调用顺序你看清楚了吗？
首先调用子类的构造方法，但是此时已经跳转到了父类的构造方法中了。
父类的构造方法结束后，才会返回到子类的构造方法中。
作者: 曹强    时间: 2014-5-24 14:01
875588381 发表于 2014-5-23 14:15
方法的调用顺序你看清楚了吗？
首先调用子类的构造方法，但是此时已经跳转到了父类的构造方法中了。
父类 ...

哦，好吧，谢谢啊



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2