CODEWITHSUNDEEP
java
codemonkey
codemonkey

Reputation: 331

Java calling Super constructor confusion

class Yfk {
public static void main(String[] args) {
     System.out.println(new YfkC().x);
  }
}
abstract class YfkA {
int x = 3;
  YfkA() { x++; }
}
class YfkB extends YfkA {}
class YfkC extends YfkB {}

The final result is 4. I am not clear about the extend process. In the main function, we create an object YfkC and invoke Yfkc.x. My understanding is since there is no method and filed in class yfkc, so we find in yfkb, and then find in yfkc. At this time, will YfkC be upcasted to YfkA automatically? Equal System.out.println(new YfkA().x); so we will get x = 4; I am confused about the process from YfkC to YfkA.

Upvotes: 0

Views: 72

Answers (3)

YoungHobbit
YoungHobbit

Reputation: 13402

new YfkC().x

This internally calls the constructor of the sub class. so the value of x is incremented and printed as 4.

YfkC() -> YfkB() -> YfkA() { x++;};

The default constructor of each class is calling the super();. This calls the default constructor of the super class before executing it's own.

If you want to know about the constructor chaining then put as system out and see the calling chain.

public  class Yfk {
  public static void main(String[] args) {
    System.out.println(new YfkC().x);
  }
}
abstract class YfkA {
  int x = 3;
  YfkA() {
    System.out.println("YfkA");
    x++; }
}
class YfkB extends YfkA {
  public YfkB() {
    System.out.println("YfkB");
  }
}
class YfkC extends YfkB {
  public YfkC() {
    System.out.println("YfkC");
  }
}

output:
YfkA
YfkB
YfkC
4

Upvotes: 2

Makoto
Makoto

Reputation: 106389

Whenever a child class is instantiated, its parent constructors are invoked in sequence, up the chain.

In your hierarchy, you have:

  • YfkC
  • YfkB
  • abstract YfkA
  • Object

...and in each of their constructors, there is an implicit call to super().

So, new YfkC invokes YfkB's constructor, which invokes the abstract class's YfkAs constructor, which results in the incrementation of x.

If you were to execute new YfkC().x again, you'd get 5, since every time you new up any of YfkA's children, you would be invoking that constructor.

Upvotes: 0

Suresh Atta
Suresh Atta

Reputation: 121998

When you invoke any Child constructor. There is a chain call to the immediate parent class constructor from the current class. And the call continues until the Object class constructor invokes since that the possible most Parent classes super class is.

Here is an example how constructor behaves in inheritance 

 public class ParentClass {  
      public ParentClass() {  
           System.out.println("Parent default constructor invoked");  
      }  
      public ParentClass(int a) {  
           System.out.println("Parent argumented constructor invoked");  
      }  
      public static void main(String[] args) {  
           SubSubClass sub = new SubSubClass();  
      }  
 }  
 class SubClass extends ParentClass {  
      public SubClass() {// not calling any super  
           System.out.println("Child default constructor invoked");  
      }  
      public SubClass(int b) {  
           super(b);  
           System.out.println("Child default constructor invoked");  
      }  
 }  
 class SubSubClass extends SubClass {  
      public SubSubClass() {// not calling any super  
           System.out.println("Sub Child default constructor invoked");  
      }  
      public SubSubClass(int b) {  
           super(b);  
           System.out.println("Sub Child default constructor invoked");  
      }  
 }  
 OUTPUT:  
 Parent default constructor invoked  
 Child default constructor invoked  
 Sub Child default constructor invoked

I wrote an article covering this topic, hope that clears your doubt.

Constructor inheritance(ovveriding) and reasons behind restricting constructor inheritance in Java

Upvotes: 1

Related Questions