Methods and Constructors

Why this matters

• Overload resolution follows strict rules, and when two candidates look equally good the compiler's choice is often not the one you expected.
• Constructor chaining is how you avoid duplicating validation across four constructors.
• An object that can be constructed in an invalid state will eventually be constructed in an invalid state.

Method signatures

A signature is the method name plus its parameter types, in order. The return type is not part of it, and neither are parameter names.

int calculate(int a, int b)          // signature: calculate(int, int)
double calculate(int a, int b)       // same signature — will not compile
int calculate(int a, long b)         // different signature — fine

Two methods differing only in return type cannot coexist, because the compiler would have no way to tell them apart at a call site.

Overloading

Overloading means several methods sharing a name but differing in parameters. The compiler chooses at compile time, in a fixed order of preference.

static void show(long value)      { System.out.println("long"); }
static void show(Integer value)   { System.out.println("Integer"); }
static void show(int... values)   { System.out.println("varargs"); }

show(5);   // prints "long"

Widening beats boxing, and boxing beats varargs. An int argument therefore widens to long rather than boxing to Integer, which surprises most people the first time.

Varargs

Varargs let a method accept any number of arguments, which arrive as an array.

static int sum(int... numbers) {
    int total = 0;
    for (int number : numbers) total += number;
    return total;
}

sum();              // 0  — an empty array, never null
sum(1, 2, 3);       // 6
sum(new int[]{4, 5});  // 9 — an array is accepted directly

Constructors

A constructor has the class's name, no return type, and runs once per object. If you declare none, the compiler supplies a no-argument default — but the moment you declare any constructor, that default disappears.

public class Account {
    private final String id;
    private final String owner;
    private double balance;

    public Account(String id, String owner, double balance) {
        if (id == null || id.isBlank()) {
            throw new IllegalArgumentException("id is required");
        }
        if (balance < 0) {
            throw new IllegalArgumentException("balance cannot be negative");
        }
        this.id = id;
        this.owner = owner;
        this.balance = balance;
    }

    public Account(String id, String owner) {
        this(id, owner, 0.0);        // chaining: must be the first statement
    }
}

static versus instance

Immutable parameters with final

Marking a parameter final prevents reassigning the parameter itself. It does not make the object it points at immutable.

void process(final List<String> items) {
    items.add("allowed");          // fine — mutating the object
    // items = new ArrayList<>();  // compile error — reassigning the parameter
}

This is a useful habit in longer methods because it removes a whole class of confusion about which value a name currently holds.

Covariant return types

An override may narrow its return type to a subtype of the original. This matters for fluent APIs and for clone().

class Shape {
    Shape copy() { return new Shape(); }
}

class Circle extends Shape {
    @Override
    Circle copy() { return new Circle(); }   // narrower return — legal
}

Callers holding a Circle now get a Circle back with no cast, while callers holding a Shape still see a Shape. Widening the return type, by contrast, would break those callers and is rejected.

Common misreadings

• "Overloading is resolved at run time." It is purely compile-time, based on declared types. Only overriding is resolved at run time.
• "A class always has a no-argument constructor." Declaring any constructor removes the compiler-generated default.
• "Return type can distinguish overloads." It cannot. Signatures are name plus parameter types only.
• "static methods can be overridden." A subclass declaring the same static signature hides it. The call is resolved by the reference type, not the object.
• "final parameters make the argument immutable." Only the binding is fixed; the object stays as mutable as it ever was.