Confused with Constructors and Subclasses

问题

I'm having trouble understanding the concept of using constructors with subclasses.

Here is the parent class:

public class A
{
    public A()
    {
        System.out.println("The default constructor of A is invoked");
    }
}

The child class:

public class B extends A
{
    public B(String s)
    {
        System.out.println(s);
    }
}

And my main method:

public class C
{
    public static void main (String[] args)
    {
        B b = new B("The constructor of B is invoked");
    }
}

When I run C, the output I get is

The default constructor of A is invoked

The constructor of B is invoked

What I don't understand is why the message from class A is getting output. Because you pass in a string argument to the constructor of the B class, shouldn't it just print out s? In other words, shouldn't the output simply be:

The constructor of B is invoked

Thanks in advance, I really appreciate any help you guys can give.

回答1:

From the docs

If a constructor does not explicitly invoke a superclass constructor, the Java compiler automatically inserts a call to the no-argument constructor of the superclass. If the super class does not have a no-argument constructor, you will get a compile-time error. Object does have such a constructor, so if Object is the only superclass, there is no problem.

So even though you've not explicitly called the super class constructor, the compiler inserts a statement called super() in the constructor of class B.

This is how the class B constructor would look post compilation.

public B(String s){
    super(); // this is inserted by the compiler, if you hadn't done it yourself.
    System.out.println(s);
}

回答2:

After compilation class B -

public class B extends A{
    public B(String s){
        super();
        System.out.println(s);
    }
}

And why! logical answer is child can not be existed without parent, so parent is initialized fast then child.

Technically - if you do not explicitly invoke super class constructor compiler will do it for you. what exactly happened in your case.

A good experiment would be if you invoke the super class contructor explicitly which help you understand this more closely-

public class B extends A{
    public B(String s){
        System.out.println(s);
        super(); // invoking super later
    }
}

you get an compilation error -

error: call to super must be first statement in constructor

So In case you are explicitly invoking the super class constructor, then you have to invoke at the start of constructor which should be first statement.

回答3:

The reason it does this is that B needs to have all the fields in A if B is indeed a subclass of A. Therefore, when you call the constructor B b = new B("The constructor of B is invoked"); It calls the default constructor of A to initialize A's fields, thus B is actually logically doing

public class B extends A
{
    public B(String s)
    {
        super();
        System.out.println(s);
    }
}

where super just calls A's default constructor. If the compiler did not do this, you would have uninitialized fields in B since it inherits from A!

来源：https://stackoverflow.com/questions/22060217/confused-with-constructors-and-subclasses

标签

java

class

constructor

subclass