子类构造函数隐式调用默认构造函数

Question

The following code gives an error when I try to create an object of type B. My question is why isn't the default constructor of A called?

class A
{
  private int a;

  A(int a)
  {
    this.a = a;
    System.out.println("This is constructor of class A");
  }
} 

class B extends A
{
  private int b;
  private double c;

  B(int b, double c)
  {
    this.b = b;
    this.c = c;
    System.out.println("This is constructor of class B");
  } 
} 

Answer 1

My question is why isn't the default contructor of A called?

Because there isn't one. When you provide your own parameterized constructor, the compiler won't add the default constructor. So, the class A which you seem to be thinking have a 0-arg constructor, doesn't have any. You've to add one explicitly.

Answer 2

The default constructor of A would imply new A(). You do not have that constructor available which means the only way to construct A is to call new A(int). Since there is no default constructor B has to explicitly call the super constructor of A to initialize A correctly.

Answer 3

因为，当Java中没有构造函数时，仅调用默认构造函数。

Answer 4

When you define your own constructor the default constructor is no longer automatically inserted by the java compiler.

In your code when B is constructed there is an implicit call on the first line to the super class construtor. super(); Although, since you have overridden the default constructor for A, there is no constructor call that will work since the compiler will not automatically call the super-class constructor with the necessary argument. You should add a line to the first line of the B constructor to call the super class constructor of A with an int argument it requires or define a constructor for A similar to the default constructor that takes no arguments.

You could overload the constructor so that one constructor is parameterless like a default constructor and then have other constructors that take parameters. :D

An example of this is as follows, based on your code:

class A
{
 private int a;

 A( int a)
 {
  this.a =a;
  System.out.println("This is constructor of class A");
}

//overload constructor with parameterless constructor similar to default 
A() { 
   System.out.println("this is like a default no-args constructor");
}
 } // end class A

class B extends A
{
 private int b;
 private double c;

   // add in another constructor for B that callers can use
   B() { 
      int b = 9;
      System.out.println("new B made in parameterless constructor");

   }

   B(int b,double c)
   {
     super(b); // this calls class A's constructor that takes an int argument :D
     this.b=b;
     this.c=c;
      System.out.println("This is constructor of class B");
  } 
}  // end class B

Answer 5

Try adding in your extended class constructor that references super class constructor ie

class B extends A
{
private int b;
private double c;
B(int b,double c, int superVal)
{
super(superVal);
this.b=b;
this.c=c;
System.out.println("This is constructor of class B");
} 
} 

Answer 6

The default constructor is a constructor which doesn't contain any arguments. If there is no suchdefault constructor,the compiler creates one, provided there shud not be any other parameterized constructor available.

In this eg, as there is a parameterized constructor available, the compiler doesn't create a default constructor. And as there is no default/parameterless constructor available , it results in compilation error