Java inheritance, whether the subclass inherits the constructor of the parent class

In inheritance in java, whether the subclass inherits the constructor of the parent class

In inheritance in java, the subclass will not inherit the constructor of the parent class, but it must call (Implicit or explicit)

Let’s look at the example:

public class TestExtends {
    public static void main(String[] args) {
        SonClass s = new SonClass(66);
    }
}

class FooClass{
    public FooClass() {
        System.out.println(100);
    }
    public FooClass(int count) {
        System.out.println(count);
    }
}

class SonClass extends FooClass{
    public SonClass() {
    }
    public SonClass(int c) {
        System.out.println(1234);
    }

}

Run result:

100
1234

Next, analyze why such a result is produced:
When the program executes the line SonClass s = new SonClass(66);, it calls

public SonClass(int c) {
    System.out.println(1234);  //在执行这行时系统会优先调用父类的无参构造函数super();
}

so the subclass When executing the above construction method, it is equivalent to executing the following code:

public SonClass(int c) {
    super(); // 必须在第一行调用,否则不能编译
    System.out.println(1234);  //在执行这行时系统会优先调用父类的无参构造函数super();
}

So the result is:
100 1234

Next, let’s introduce another In this case (explicit call), if the subclass constructor is written like this:

public SonClass(int c) {
    super(2); // 必须写在第一行,否则不能编译,显式调用父类构造函数后,系统就不在默认调用无参构造函数了
    System.out.println(1234);
}

The execution structure is:
2 1234

Summary :

• The constructor cannot be inherited and is only used to call in subclasses. (If the parent class does not have a parameterless constructor, it must be used when creating a subclass. Explicitly call the parameterized constructor of the parent class in the first line of the subclass constructor code body, otherwise it cannot be compiled);

• If the parent class does not have a parameterized constructor, then in When creating a subclass, you do not need to explicitly call the parent class constructor. The system will call the parent class's no-argument constructor by default super();

• If the parent class If there is no parameterless constructor, the system cannot adjust the default parameterless constructor, so the compilation cannot pass without displaying the call;

Additional explanation :

1. In java, after creating a parameterized constructor, the system no longer has a default parameterless constructor

2. If If there is no constructor in the parent class, the system will have a parameterless constructor by default

The above is the detailed content of Java inheritance, whether the subclass inherits the constructor of the parent class. For more information, please follow other related articles on the PHP Chinese website!