Java Constructor Inheritance

java

constructor-inheritance

design-patterns

best-practices

byAlex Kataev·Jan 8, 2025

In Java, subclasses don't inherit constructors from superclasses. For the instantiation of a subclass, it's required to define a constructor, and if necessary, invoke the superclass constructor using super(). Let's dive into this through a simple example:

class Superclass {
    Superclass(int num) { /* some Java magic happens here 🎩✨*/ }
}

class Subclass extends Superclass {
    Subclass() {
        super(42);  // Calls Superclass constructor, because even Java 🧞‍♂️ has three wishes
    }
}

Don't forget, without super(42);, Java is incapable of pairing any inherited constructor, as a default constructor is non-existing if a parameterized constructor is defined in the superclass itself.

Why no automatic inheritance of constructors?

In the realm of Java, an explicit definition of constructors in subclasses is mandatory due to its several advantages:

Explicitness: Constructors define the blueprint for creation of an object. Inheritance could lead to creation of objects in uninitialized or invalid states, paving the way to potential runtime tantrums.
Flexibility: Subclasses often have dissimilar properties or require a different process of initialization than the superclass. By crafting your own constructors, you ensure that these nuances are dealt with explicitly.

Beware of these constructor traps!

When dealing with constructors in subclasses, it's crucial to stay aware of the following traps:

Overloading vs Overriding : Constructors certainly can be overloaded, but overriding them? Nah. It's important to offer diverse parameter lists for overloaded constructors to avoid confusion or as Java likes to call it, ambiguity.
Unexpected default constructors : If you define a constructor with parameters in a superclass, don't expect the compiler to gift you a default constructor. Remember to define a no-argument constructor if needed.

Go with Strategy, not Inheritance

Instead of banking on constructor inheritance, design patterns like Strategy or Factory Method can come to your rescue for object creation. Separation of concern and reusability of initialization logic is key with these patterns.

Reflect on your class relationships

Every now and then, reflecting on your class hierarchy and construction logic can prove beneficial:

Are you respecting the Liskov Substitution Principle?: If your constructors are turning specific states unsupported by the superclass, you might be dealing with a violation of this principle.
Factory methods: Consider utilising factory methods to encapsulate the tedious process of object creation for more flexible instantiation and better decoupling.

Seek wisdom from veterans

Seasoned programmers like Jon Skeet offer valuable insights into Java design patterns - an essential reason why explicit constructors are so critical in ensuring initialization invariants and clearer communication of object creation prerequisites.

explain-codes / Java / Java Constructor Inheritance

Linked

Should I initialize variable within constructor or outside constructor



Constructor in an Interface?



What's wrong with overridable method calls in constructors?



How do I call one constructor from another in Java?



Initialize class fields in constructor or at declaration?

