Question

public class F {
    protected int a=0, b=0;
   public F() {
     a = 2;
     b = 2;
     }
  public void increase() {
     upA();
  } 
  public void upA() {
     a = a + 1;
  }
  public String toString() {
     return a+" "+b;
   }
 }

 public class G extends F {
      public void increase() {
            super.increase();
            upB();
      }
     public void upA() {
            a = a + a;
     }
     public void upB() {
          b = b + 1;
   }
 }

以下Java片段在“输出”窗口中打印了什么？

 G g = new G();
 g.increase();
 System.out.println(g);

有人可以向我解释为什么答案是4,3

（即调用了子类方法，即使我调用了super.increase（），它调用了超类中的upA方法？）

Answer 1

虚拟调用所有方法，并应用覆盖。所以F中的代码：

public void increase() {
    upA();
}

...正在调用G.upA()，因为它调用upA()的对象是G的实例。

因此increase()的执行流程为：

G.increase()来电super.increase()
- F.increase()来电upA()
- G.upA()执行（所以a = 4）
G.increase()来电upB()
- G.upB()执行（所以b = 3）

Answer 2

将increase（）视为像这样实现

public void increase() {
  this.upA();
}

然后问问自己这个＆＃34;这个＆＃34;是

你正在看到＆＃34;多态＆＃34;行为，它是对象语言的一个非常强大的功能。

请注意，您可以写

  F gInDisguiseAsAnF = new G();

  gInDisguiseAsAnF.increase();

仍然得到相同的结果。根据新创建的类型选择了哪个版本的upA（）方法。

Answer 3

  public void increase() {
  upA();
  }

与this.upA()相同，因此G中的方法被调用，因为this是G的实例。

调用super不会仅以超类型限制当前实例。

Answer 4

这是从F

的increase（）调用的

public void upA() {
 a = a + a; // a=2+2 
  }

不

  public void upA() {
  a = a + 1; //not a=2+1
  }

从子类调用重写的超类方法

4 个答案: