Constructor Inheritance

In Java, constructors are not directly inherited by subclasses like other methods and fields. However, there is a concept called constructor chaining or implicit constructor invocation, which allows subclasses to implicitly call a constructor of the superclass before executing their own constructor code.

Here's how constructor inheritance works in Java:

1. Implicit Constructor Invocation:

   - When you create an instance of a subclass, Java automatically invokes a constructor of the superclass before executing the constructor code of the subclass.

   - If the subclass constructor does not explicitly call a superclass constructor using `super(...)`, Java will automatically call the no-argument constructor of the superclass.

2. Explicit Constructor Invocation:

   - If the superclass does not have a no-argument constructor, or if the subclass constructor wants to call a specific superclass constructor with arguments, you must explicitly invoke the superclass constructor using `super(...)`.

   - This explicit invocation of the superclass constructor must be the first statement in the subclass constructor.

Here's an example to illustrate constructor inheritance in Java:

class Vehicle {

    String make;

    // Superclass constructor

    Vehicle(String make) {

        this.make = make;

        System.out.println("Vehicle constructor invoked");

    }

}

class Car extends Vehicle {

    String model;

    // Subclass constructor

    Car(String make, String model) {

        super(make); // Invoking superclass constructor explicitly

        this.model = model;

        System.out.println("Car constructor invoked");

    }

}

public class Main {

    public static void main(String[] args) {

        Car myCar = new Car("Toyota", "Camry");

        System.out.println("Make: " + myCar.make);

        System.out.println("Model: " + myCar.model);

    }

}

In this example:

- The `Car` class extends the `Vehicle` class.

- The `Vehicle` class has a constructor that takes a `make` parameter.

- The `Car` class constructor explicitly invokes the `Vehicle` constructor using `super(make)` to initialize the `make` field inherited from the superclass.

- When you create an instance of `Car`, both the `Vehicle` constructor and the `Car` constructor are invoked, ensuring that the `make` field is initialized properly.

So, while constructors are not directly inherited in Java, constructor chaining ensures that constructors of the superclass are invoked before executing the subclass constructors, thereby facilitating constructor inheritance.