Should You Always Use `super()` in Constructors?

Is the Presence of super() in Constructors Optional?

In object-oriented programming, it's common practice to utilize constructors in derived classes to invoke Constructors in their superclasses. However, some developers question the necessity of explicitly specifying super() within constructors.

Compiler's Automatic Invocation of super()

The Java compiler automatically inserts a call to the accessible no-args constructor of the superclass if the subclass constructor doesn't specify a superclass constructor. This means that in most cases, the omission of super() doesn't affect the behavior of the program.

Exceptions to the Rule

However, there are situations where explicit invocation of super() is required:

• If the superclass doesn't have an accessible no-args constructor.
• If the subclass constructor has arguments and the superclass has a constructor that accepts arguments.
• If the subclass constructor needs to invoke a specific constructor in the superclass other than the default no-args constructor.

Constructor Usage in Presence of Arguments

When a subclass constructor has arguments, it's the responsibility of the subclass constructor to pass appropriate arguments to the superclass constructor. The compiler won't automatically invoke a superclass constructor with arguments unless explicitly specified.

Example

Consider the following code:

<code class="java">public class Base {
    private Base() {}
}

public class Derived extends Base {
    public Derived(int i) {
        super(); // Call the default no-args constructor of Base
    }
}</code>

In this example, the super() call in the Derived constructor is essential because Base has a private no-args constructor.

The above is the detailed content of Should You Always Use `super()` in Constructors?. For more information, please follow other related articles on the PHP Chinese website!