How do I call one constructor from another in Java?

java

constructor-overloading

best-practices

object-initialization

byNikita Barsukov·Sep 27, 2024

In Java, you can call another constructor from one constructor within the same class. This is done using this() and the appropriate parameters. Here is an example:

public class MyClass {
    private int x;
    private int y;
    
    // When no parameters, we assume zero
    public MyClass() {
        this(0, 0); // Delegates to the constructor below (it's playing "pass the buck")
    }
    
    // When one parameter, we assume zero for y
    public MyClass(int x) {
        this(x, 0); // Our constructor, the above constructor's "buck" has been passed to
    }
    
    // Can't delegate further, it's the end of the buck passing road
    public MyClass(int x, int y) {
        this.x = x;
        this.y = y; // Core constructor initiates both x and y
    }
}

Remember, this() must be the first statement in a constructor to ensure proper and efficient initialization of your variables.

Embracing constructor overloading

In real-life coding scenarios, there may be times when you need to initialize an object differently based on the given context. Constructor overloading comes to the rescue for such scenarios, allowing for a variety of parameter combinations.

Default values with constructor overloading

Here's an example that demonstrates how to use default values when certain information isn't provided, and custom values when it is:

public class BongoDrum {
    private String size;
    private String color;

    // Default constructor, one-size-fits-all... colorblind 
    public BongoDrum() {
        this("Big", "Unpainted"); // You get big, unpainted drums. Cool, right?
    }

    // Partially informed constructor for size conscious drummers
    public BongoDrum(String size) {
        this(size, "Unpainted"); // You get to pick the size, but we're still not painting it 
    }

    // Fully informed constructor for picky drummers
    public BongoDrum(String size, String color) {
        this.size = size;
        this.color = color; // Now you got your custom drums
    }
}

Always validate parameters to avoid passing any unpleasant surprises (bucks) to the called constructor.

Centralized constructor logic

Factoring out common logic in a private helper method boosts code reusability and maintainability. Here's an example:

private void init(String size, String color) {
    assert size != null : "Drum size cannot be a null, it must have SOME size!";
    assert color != null : "Color cannot be null, even unpainted is a color!";
    this.size = size; // TIP: Practice the drums daily for max life enjoyment
    this.color = color; // Remember: color has nothing to do with the sound 
}
public BongoDrum(String size, String color) {
    init(size, color); // Easier to manage one task at a time
}

Your future self will thank you for this centralized logic when changes are needed.

`super()`: reaching out to superclass constructor

Java also provides super() to call a constructor from the superclass:

public class SubClass extends SuperClass {
    public SubClass() {
        super(); // Reaching out to mom superclass's constructor
        // You can start your process now
    }
}

A bypass with static methods

Static methods provide an alternate pathway around some this() restrictions for initializations:

public class Book {
    private String title;
    private String author;

    private Book(String title) {
        this.title = title;
    }

    // Static factory method for book worms
    public static Book createBook(String title, String author) {
        Book book = new Book(title);
        book.author = author; // We'll let you handle who gets the spotlight
        return book;
    }
}

Here, the createBook method can include pre-validation logic or perform any other pre-creation operations on the inputs.

Practical usage and pitfalls

The process of constructor chaining could be a slippery slope if not handled wisely:

Consistent Parameter Order: Following the same parameter order prevents confusion. Nobody likes jumbled up parameters!
Immutable State: Once constructed, the object state shouldn't normally change. It's good manners!

Note: Although constructor chaining can make your life easier, too much of it can lead to confusion and reduced code readability.

explain-codes / Java / How do I call one constructor from another in Java?

Linked

Should I initialize variable within constructor or outside constructor



Using Pairs or 2-tuples in Java



What is the best way to implement constants in Java?



How to initialize HashSet values by construction?



Make arrayList.toArray() return more specific types