子类中的超级构造函数-Java

Question

Considering the following code example, can someone help to explain why the result of B b3= new B (20, 50) ; System.out.println(b3) ; is A:20, B:(10, 61) ? I thought through calling the super (x) , we uses the A(int x) {this x =x;} and int x of B has been changed to 20.

PS: I'm looking for the reason behind how it works but not how to print out certain value in B.

class A {
  int x;
  A(int x) {
    this.x = x; 
  }
  public String toString() {
     return "A:" + x;
  } 
}
 class B extends A {
   int x = 10;
   int y = x+1;

   B(int x, int y) {
     super(x);
     this.y = this.y + y;
   }
   public String toString() {
     return "A:" + super.x + ", B:(" + x + "," + y + ")";
   }
}

Answer 1

As many others have meanwhile pointed out, attributes are resolved statically in Java, while methods are resolved dynamically. This means that attributes shadow while methods overwrite . Casting a variable up to its superclass (as happens implicitly to the this pointer) will not affect how methods are resolved but does change how attributes are.

The second thing is that even if A 's constructor in your example were to assign to Bx , it would happen before the B -part of the object is constructed (as objects are constructed starting with Object 's constructor and then walking down the class hierarchy [1]) and the constructor of B would overwrite it. You can verify that the constructor of A sees an uninitialized B by (only for academic purpose, please) downcasting the this pointer in A 's constructor and inspecting Bx . It will be 0.

class A {
    int x;
    A(int x) {
        System.out.printf("A() before: A.x = %d%n", this.x);  // 0
        System.out.printf("A() before: B.x = %d%n", (B) this).x);  // 0
        this.x = x;
        System.out.printf("A() after: A.x = %d%n", this.x);  // 7
        System.out.printf("A() after: B.x = %d%n", (B) this).x);  // 0
    }
}

class B extends A {
    int x = 10;
    B() {
        super(7);
        System.out.printf("B(): A.x = %d%n", super.x);  // 7
        System.out.printf("B(): A.x = %d%n", this.x);  // 10
    }
}

Notes:

1. This might seem illogic: After all, isn't A 's constructor called from within B 's? It turns out that super() is not a normal method invocation but a special feature.

Answer 2

Your class B is shadowing the int x from A . If you don't do that,

class B extends A {
  // int x = 10; // <-- shadows A.x
  int y = x+1;

  B(int x, int y) {
    super(x);
    this.y = this.y + y;
  }
  public String toString() {
    return "A:" + super.x + ", B:(" + x + "," + y + ")";
  }
}

Then your code would work as you expected. Your shadow means there are literally two variables named x . To get the parent one you need super.x (as you already did).

Answer 3

we uses the A(int x) {this x =x;} and int x of B has been changed to 20.

Actually, no. It hasn't been changed to 20 . It was never 10 in the first place.

There are two separate x instance variables, one declared in A and one in B .

• In A (int x) { this.x = x; } A (int x) { this.x = x; } , the this.x is the x declared in A .

• In class B extends A { int x = 10; ... class B extends A { int x = 10; ... the x is a different one.

When you assign to one of the x variables, it does not alter the other one. They are distinct .

---

What this problem / example is intended to illustrate is shadowing ... where one variable in the superclass gets "sort of hidden" by another variable in the subclass. From a design / coding perspective, it is a bad idea. You should avoid doing this in real code.

Answer 4

The reason is that you have two x variables -- one in A and one in B , so when you call super(x) , it goes to the constructor in A , which, because it's in A , assigns A 's x to the argument of super(x) . So it sets super.x to 20 , but doesn't change the x in B . So B s x stays at the 10 it was originally initialized as.

Answer 5

B(int x, int y) constructor has same argument name as instance variable so x pass to super constructor A will be the one which is pass to constructor B and it is not related to instance variable x. Instance variable x(defined as int x=10;) value will be change only when refer by this.x from B's constructor. 'this' keyword used to refer to object that call the function. So no matter what you pass B(any value, y), it will display 10 for x as output as we are not changing value of x.

Does this make sense?