Constructor Overloading in Java

Think about creating a new user account. Sometimes you have all their details, sometimes just an email, sometimes just a username. You don't want to force callers to provide everything when they don't have it. That's where constructor overloading comes in handy.

What is Constructor Overloading?

Constructor overloading occurs when a class has multiple constructors with different parameter lists. Like method overloading, constructors can be overloaded by:

Different number of parameters
Different types of parameters
Different order of parameters

Basic Example

public class Student {
    private String name;
    private int age;
    private String studentId;
    private String major;
    
    // Constructor with no parameters (default constructor)
    public Student() {
        this.name = "Unknown";
        this.age = 18;
        this.studentId = "N/A";
        this.major = "Undeclared";
    }
    
    // Constructor with name only
    public Student(String name) {
        this.name = name;
        this.age = 18;
        this.studentId = "N/A";
        this.major = "Undeclared";
    }
    
    // Constructor with name and age
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        this.studentId = "N/A";
        this.major = "Undeclared";
    }
    
    // Constructor with all parameters
    public Student(String name, int age, String studentId, String major) {
        this.name = name;
        this.age = age;
        this.studentId = studentId;
        this.major = major;
    }
}

Rules for Constructor Overloading

1. Same Constructor Name

All constructors must have the same name as the class.

2. Different Parameter Lists

Parameter lists must differ in at least one of these ways:

Different Number of Parameters

public class Rectangle {
    private double length;
    private double width;
    
    public Rectangle() {
        this.length = 1.0;
        this.width = 1.0;
    }
    
    public Rectangle(double side) {
        this.length = side;
        this.width = side;
    }
    
    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }
}

Different Parameter Types

public class Temperature {
    private double celsius;
    
    public Temperature(int fahrenheit) {
        this.celsius = (fahrenheit - 32) * 5.0 / 9.0;
    }
    
    public Temperature(double celsius) {
        this.celsius = celsius;
    }
    
    public Temperature(String tempString) {
        // Parse temperature from string
        this.celsius = Double.parseDouble(tempString.replace("°C", ""));
    }
}

Different Parameter Order

public class Point {
    private double x;
    private double y;
    
    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }
    
    public Point(double value, boolean isX) {
        if (isX) {
            this.x = value;
            this.y = 0;
        } else {
            this.x = 0;
            this.y = value;
        }
    }
}

3. No Return Type

Constructors do not have return types, not even void.

4. Access Modifiers

Constructors can have different access modifiers:

public class Example {
    private Example() { }                    // Private constructor
    Example(int param) { }                   // Package-private
    protected Example(int a, int b) { }      // Protected
    public Example(int a, int b, int c) { }  // Public
}

Constructor Chaining

Constructor overloading often involves constructor chaining using this():

public class Person {
    private String name;
    private int age;
    private String address;
    
    public Person() {
        this("Unknown", 0, "Unknown");
    }
    
    public Person(String name) {
        this(name, 0, "Unknown");
    }
    
    public Person(String name, int age) {
        this(name, age, "Unknown");
    }
    
    public Person(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }
}

Common Constructor Overloading Patterns

1. Default Values Pattern

public class DatabaseConnection {
    private String host;
    private int port;
    private String username;
    private String password;
    
    public DatabaseConnection() {
        this("localhost", 5432, "postgres", "");
    }
    
    public DatabaseConnection(String host) {
        this(host, 5432, "postgres", "");
    }
    
    public DatabaseConnection(String host, int port) {
        this(host, port, "postgres", "");
    }
    
    public DatabaseConnection(String host, int port, String username, String password) {
        this.host = host;
        this.port = port;
        this.username = username;
        this.password = password;
    }
}

2. Builder Pattern Alternative

public class Email {
    private String to;
    private String subject;
    private String body;
    private String attachment;
    
    public Email(String to) {
        this(to, "", "", null);
    }
    
    public Email(String to, String subject) {
        this(to, subject, "", null);
    }
    
    public Email(String to, String subject, String body) {
        this(to, subject, body, null);
    }
    
    public Email(String to, String subject, String body, String attachment) {
        this.to = to;
        this.subject = subject;
        this.body = body;
        this.attachment = attachment;
    }
}

3. Type Conversion Pattern

public class Money {
    private long cents;
    
    public Money(int dollars) {
        this.cents = dollars * 100L;
    }
    
    public Money(double dollars) {
        this.cents = Math.round(dollars * 100.0);
    }
    
    public Money(long cents) {
        this.cents = cents;
    }
    
    public Money(String dollarString) {
        double dollars = Double.parseDouble(dollarString.replace("$", ""));
        this.cents = Math.round(dollars * 100.0);
    }
}

Best Practices

1. Use Constructor Chaining

Always chain constructors to avoid code duplication:

// Good
public class GoodExample {
    public GoodExample() {
        this("default");
    }
    
    public GoodExample(String value) {
        this.value = value;
    }
}

// Avoid
public class BadExample {
    public BadExample() {
        this.value = "default";
        // Duplicate initialization code
    }
    
    public BadExample(String value) {
        this.value = value;
        // Duplicate initialization code
    }
}

2. Validate Parameters

Validate constructor parameters and throw exceptions for invalid values:

public class Age {
    private int years;
    
    public Age(int years) {
        if (years < 0 || years > 150) {
            throw new IllegalArgumentException("Age must be between 0 and 150");
        }
        this.years = years;
    }
}

3. Document Constructors

Use Javadoc to document each constructor's purpose:

/**
 * Creates a new Person with default values.
 */
public Person() { }

/**
 * Creates a new Person with the specified name.
 * @param name the person's name
 */
public Person(String name) { }

4. Consider Factory Methods

For complex object creation, consider static factory methods:

public class ComplexObject {
    private ComplexObject() { }
    
    public static ComplexObject createDefault() {
        return new ComplexObject();
    }
    
    public static ComplexObject createFromConfig(Config config) {
        ComplexObject obj = new ComplexObject();
        // Complex initialization
        return obj;
    }
}

Wrapping Up

Constructor overloading gives you flexibility in how objects get created. It's the same idea as method overloading, just applied to constructors. Combine it with constructor chaining, and you've got a solid pattern for building objects without repeating yourself.