Can We Have Constructor In Abstract Class In Java

MUAZHAN

4 min read

·

Jun 24, 2024

49

Share

Can We Have a Constructor in an Abstract Class in Java?

The answer is yes, we can have a constructor in an abstract class in Java. However, it's important to understand why and how we would use them.

Why Have a Constructor in an Abstract Class?

Abstract classes are designed to be extended by other classes. While they cannot be directly instantiated, they provide a blueprint for concrete subclasses.

The primary reason for having a constructor in an abstract class is to initialize common fields or perform shared setup for all subclasses. This avoids code duplication and ensures consistency across all inheriting classes.

How Constructors Work in Abstract Classes

When a subclass constructor is called, the abstract class's constructor will be implicitly called before the subclass constructor's code executes. This happens due to the concept of constructor chaining, where the parent class's constructor is automatically invoked before the child class's constructor.

Here's an example:

abstract class Shape {
    private String color;

    // Constructor to initialize the color
    public Shape(String color) {
        this.color = color;
    }

    // Abstract method to calculate area
    public abstract double calculateArea();
}

class Circle extends Shape {
    private double radius;

    public Circle(String color, double radius) {
        super(color); // Call the abstract class constructor
        this.radius = radius;
    }

    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

public class Main {
    public static void main(String[] args) {
        Circle myCircle = new Circle("Red", 5.0);
        System.out.println("Area of the circle: " + myCircle.calculateArea());
    }
}

In this example:

• The Shape abstract class has a constructor that initializes the color field.
• The Circle subclass extends Shape and calls the Shape constructor (super(color)) to initialize the color field before initializing its own radius field.

Key Points to Remember

• You cannot create instances of abstract classes directly, so you'll never explicitly call the abstract class constructor.
• The primary purpose of a constructor in an abstract class is to initialize common fields or perform shared setup for subclasses.
• The abstract class constructor is automatically invoked when a subclass constructor is called.

Understanding constructors in abstract classes is essential for effective object-oriented programming in Java. By using them strategically, you can promote code reusability, maintain consistency, and create a robust and maintainable codebase.