核心Java动态绑定

Question

Please tell the reason for output we are getting.

As per me, with b.getx() we will get the reference id of object of B and b.getx().x should get value of 10 but when I run this program the output is 5.

class Base {
  int x = 5;
  public Base getx() {
    return new Base();
  }
}

class Child extends Base {
  int x = 10;
  public Child getx() {
    return new Child();
  }

  public static void main(String ...s) {
    Base b = new Child();
    System.out.println(b.getx().x);
  }
}

Answer 1

Field accesses (unlike method calls) are not subject to runtime dynamic dispatch, they're resolved purely based on compile-time types.

The variable b is of compile-time type Base , therefore b.getx() is also of compile-time type Base , and so b.getx().x will be compiled into an access of Base's x field, not Child's. This is confirmed by looking at the output of javap for the main method:

public static void main(java.lang.String[]);
  Code:
   0:   new #3; //class Child
   3:   dup
   4:   invokespecial   #4; //Method "<init>":()V
   7:   astore_1
   8:   getstatic   #5; //Field java/lang/System.out:Ljava/io/PrintStream;
   11:  aload_1
   12:  invokevirtual   #6; //Method Base.getx:()LBase;
   15:  getfield    #7; //Field Base.x:I
   18:  invokevirtual   #8; //Method java/io/PrintStream.println:(I)V
   21:  return

you can see that b.getx().x was compiled into a getfield instruction for Base.x specifically.

Answer 2

Dynamic binding basically means that the method implementation that is actually called is determined at run-time, and not at compile-time. And that's why it's called dynamic binding – because the method that will be run is chosen at run time. Dynamic binding is also known as late binding.

Answer 3

Base b = new Child(); is resolve at run-time and by rules of dynamic binding(run-time polymorphism) all method related to that should bind at run-time so...

public Base getx() {
    return new Base();
  }

that lines return new instance of base class and you just called variable on that instance.

Answer 4

Dynamic Binding is runtime time process for looking the declaration at run time. It is also known as late binding in which a call to an overridden method is resolved at runtime rather than compile-time. In an object-oriented system method overriding (dynamic Polymorphism) is done at run time. When overriding one method with another, the signatures of the two methods must be identical.

Example:

class Animal{

  public void eat(){
      System.out.println("Animals voice");
   }

public void go(){
      System.out.println("Animals can walk");
   }

}

class Dog extends Animal{

   public void go(){
      System.out.println("Dogs can walk and run");
   }
   public void eat(){
      System.out.println("Dogs can eat a wide range of foods");
   }
}