constructor of subclass in Java

Solution 1:

When creating an Employee you're creating a Person at the same time. To make sure the Person is properly constructed, the compiler adds an implicit call to super() in the Employee constructor:

 class Employee extends Person {
     Employee(int id) {
         super();          // implicitly added by the compiler.
     }
 }

Since Person does not have a no-argument constructor this fails.

You solve it by either

• adding an explicit call to super, like this:

   class Employee extends Person {
       Employee(int id) {
           super(id);
       }
   }
  

• or by adding a no-arg constructor to Person:

  class Person {
      Person() {
      }
  
      Person(int a) {
      }
  }
  

Usually a no-arg constructor is also implicitly added by the compiler. As Binyamin Sharet points out in the comments however, this is only the case if no constructor is specified at all. In your case, you have specified a Person constructor, thus no implicit constructor is created.

Solution 2:

The constructor for Employee doesn't know how to construct the super-class, Person. Without you explicitly telling it, it will default to trying the no-args constructor of the super-class, which doesn't exist. Hence the error.

The fix is:

class Employee extends person {
    public Employee(int id) {
        super(id);
    }
}

Solution 3:

Java actually views this code as:

class Person {
  Person(int nm) { }
 }
 class Employee extends Person {
    Employee(int id) {
        super();
    }
 }
 public class EmployeeTest1 {
    public static void main(String[] args){ }
 }

Since there is no Person() constructor this fails. Instead try:

class Person {
  Person(int nm) { }
 }
 class Employee extends Person {
    Employee(int id) {
        super(id);
    }
 }
 public class EmployeeTest1 {
    public static void main(String[] args){ }
 }

Solution 4:

Java provides you with a default constructor which takes no parameters. The constructor also has no body, so it is something like so: public Person() {}. The moment you define you own constructor, your constructor(s) take place of the default one, so in your case, Person(int nm){} takes place of Person() { }. Your call is trying to implicitly call Person() { } and since this constructor no longer exists, the code is failing. Take a look at this previous SO question for more information.

Solution 5:

Above answer is correct, some addition: you can straight call to super(int n) to avoid implicitly adding super() here:

class Employee extends Person {
    Employee(int id) { super(int id);}
}

1. If you write no constructor, compiler implicitly add default (without parameters) to your class.
2. If you write any constructor - compiler will not add default constructor.

PS:Sorry for my writing. English is not my native language.