Statements Before super() in Java

Last updated: June 20, 2024

Written by: Mohamed Helmy

Reviewed by: Michal Aibin

Core Java

Java Constructor

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.

Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.

In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:

>> Flexible Pub/Sub Messaging With Spring Boot and Dapr

1. Introduction

In Java programming, we use the super() keyword to invoke the superclass constructor. However, there are specific rules regarding the placement of statements before the super() call within subclass constructors.

In this tutorial, we’ll delve into the importance of super(), the implications of placing statements before it, and the best practices to follow.

2. Understanding the Role of super()

When a subclass is instantiated, its constructor implicitly invokes the constructor of its superclass using super(). This ensures that the superclass part of the object is properly initialized before the subclass constructor proceeds with its initialization logic.

Moreover, omitting or incorrectly placing the super() call can lead to compilation errors or unexpected runtime behavior.

3. The Importance of Placement

Java enforces a strict rule regarding placing the super() call within subclass constructors. It must be the first statement within the constructor.

Placing statements before super() violates this rule and results in a compilation error. Let’s consider an example to illustrate this point:

class Parent {
    Parent() {
        System.out.println("Parent constructor");
    }
}

class Child extends Parent {
    Child() {
        System.out.println("Child constructor");
        super();
    }
}

In this example, attempting to invoke super() after printing a message in the Child constructor will lead to a compilation error (Constructor call must be the first statement in a constructor).

To address the compiler error, let’s correct the Child class:

class Parent {
    Parent() {
        System.out.println("Parent constructor");
    }
}

class Child extends Parent {
    Child() {
        super();
        System.out.println("Child constructor");
        additionalInitialization();
    }

    private void additionalInitialization() {
        System.out.println("Additional initialization in Child");
    }
}

Here, we place the super() call as the first statement within the subclass constructor.

4. Best Practices for Using super()

When working with superclass constructors and the super() keyword in Java, we should follow these best practices to ensure clarity and maintainability:

4.1. Avoid Overloading Superclass Constructors Unnecessarily

Overloading superclass constructors should be done judiciously. Ensure that overloaded constructors maintain consistency in initializing essential superclass states to prevent unexpected behavior in subclasses.

4.2. Pass Required State Through Constructor Parameters

If the subclass requires specific state initialization in addition to the superclass, pass this state through constructor parameters rather than relying solely on superclass initialization. This promotes explicitness and reduces coupling between classes.

4.3. Document Initialization Logic

Document any significant initialization logic, especially involving interactions between superclass and subclass constructors. Clear documentation enhances code readability and helps other developers understand the constructor’s purpose and expected behavior.

5. Conclusion

In conclusion, understanding the sequence of statements within Java constructors, particularly the placement of super() calls, is fundamental for constructing robust and well-organized code.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.