Java Implicit Super Constructor is Undefined Error

Last updated: January 8, 2024

Written by: Sachin Kumar

Reviewed by: Eric Martin

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. Overview

In this tutorial, we’ll take a closer look at the Java “implicit super constructor is undefined” error. First, we’ll create an example of how to produce it. Next, we’ll explain the leading cause of the exception, and later we’ll see how to fix it.

2. Practical Example

Now, let’s see an example that generates a compilation error “Implicit super constructor X() is undefined. Must explicitly invoke another constructor”.

Here, X represents the parent class that is extended by any subclass that sees this error.

First, let’s create a parent class Person:

public class Person {

    String name;
    Integer age;

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

   // setters and getters
}

Now, let’s create a subclass Employee whose parent is Person:

public class Employee extends Person {

    Double salary;

    public Employee(String name, Integer age, Double salary) {
        this.salary = salary;
    }

    // setters and getters
}

Now, in our IDE, we’ll see the error:

Implicit super constructor Person() is undefined. Must explicitly invoke another constructor

In some cases, we can get a similar error if the child class doesn’t have a constructor.

For instance, let’s consider the Employee with no constructor:

public class Employee extends Person {

    Double salary;

    // setters and getters
}

We’ll see the error in our IDE:

Implicit super constructor Person() is undefined for default constructor. Must define an explicit constructor

3. Cause

In Java inheritance, constructor chaining refers to calling a sequence of constructors using the super method to chain constructors from the parent class. Subclass constructors must invoke the superclass constructor, either explicitly or implicitly. Either way, a super constructor must be defined.

A class that has no parent has the Object class as its parent. The Object class in Java has a constructor with no arguments.

When a class does not have a constructor, the compiler adds a default constructor that takes no arguments, and in the first statement, the compiler inserts a call to super – which calls the constructor of the Object class.

Let’s assume that our Person class doesn’t contain any constructor and has no parent. Once we compile, we can see the compiler has added the default constructor:

public Person() {
    super();
}

In contrast, if there is already a constructor in the Person class, this default, no-args constructor is not added by the compiler.

Now, if we create subclass Employee that extends Person, we get an error in the Employee class:

Implicit super constructor Person() is undefined for default constructor. Must define an explicit constructor

Since the compiler will insert a super call to the Employee constructor, it won’t find a constructor without parameters in the parent class Person.

4. Solution

To resolve this error, we need to explicitly provide information to the compiler.

The first thing we need to do is to explicitly call the super constructor from the Employee constructor:

public Employee(String name, Integer age, Double salary) {
    super(name, age);
    this.salary = salary;
}

Now, let’s say we need to create an Employee object with only the salary field. Let’s write the constructor:

public Employee(Double salary) {
    super();
    this.salary = salary;
}

Despite adding the super call to the Employee constructor, we still receive an error because the Person class still lacks a matching constructor. We can fix this by creating an argument-less constructor explicitly in the Person class:

public Person(String name, Integer age) {
    this.name = name;
    this.age = age;
}

public Person() {
}

Finally, thanks to these changes, we won’t get compilation errors.

5. Conclusion

We’ve explained Java’s “implicit super constructor is undefined” error. Then, we discussed how to produce the error and the cause of the exception. Lastly, we discussed a solution to resolve the error.

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.