Can Abstract Class Have Parameterized Constructor In Java

MUAZHAN

4 min read

·

Jun 24, 2024

57

Share

Can Abstract Classes Have Parameterized Constructors in Java?

In Java, abstract classes are designed to be blueprints for other classes, providing common functionality and structure. They cannot be instantiated directly, meaning you can't create objects of an abstract class. However, abstract classes can have parameterized constructors.

Why Parameterized Constructors in Abstract Classes?

While you cannot directly create objects of an abstract class, its constructors play a crucial role:

• Initializing instance variables: Constructors in abstract classes are used to initialize the instance variables that will be inherited by concrete subclasses. These variables may be needed for the functionality implemented in the subclasses.
• Providing consistent initialization: By defining a parameterized constructor in the abstract class, you ensure that all subclasses inherit a consistent way of initializing their common members.

How it Works

Let's illustrate this with a simple example:

abstract class Shape {
    private int sides;

    // Parameterized constructor to initialize 'sides'
    public Shape(int sides) {
        this.sides = sides;
    }

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

class Square extends Shape {
    public Square(int sideLength) {
        super(4); // Calling the parameterized constructor of Shape
    }

    @Override
    public double calculateArea() {
        return sideLength * sideLength;
    }
}

class Circle extends Shape {
    public Circle(double radius) {
        super(0); // Calling the parameterized constructor of Shape 
    }

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

In this example, the Shape class is abstract. It defines a parameterized constructor to initialize the sides variable. Both Square and Circle subclasses inherit this constructor. They call the super constructor with appropriate values to set the number of sides (4 for square, 0 for circle). This ensures that the sides variable is properly initialized in both subclasses.

Key Points:

• Constructors in abstract classes are not directly called to create objects. They are used to initialize common members inherited by subclasses.
• Subclasses must call the constructor of their parent (abstract class) using the super keyword. This ensures proper initialization.
• Parameterized constructors in abstract classes help enforce consistency and provide a clear way to initialize common attributes.

In conclusion, abstract classes in Java can have parameterized constructors to initialize common members and ensure consistent initialization across subclasses. While you cannot create objects of abstract classes directly, their constructors are essential for proper initialization within the inheritance hierarchy.