methods

the picture

a method is a recipe card. the name is the title, the parameters are the ingredient list ("2 eggs, 1 cup flour"), the body is the instructions, and the return value is the dish you hand back. every time someone cooks from the card, they start with their own fresh ingredients (a new frame) and the card itself never changes.

public static int max(int a, int b) {
    int bigger = a > b ? a : b;
    return bigger;
}

public class Main {
    static int max(int a, int b) {
        int bigger = a > b ? a : b;
        return bigger;
    }
 
    public static void main(String[] args) {
        IO.println(max(3, 7) + " " + max(-2, -9));
    }
}

7 -2

what a call actually does

calling a method pushes a new frame onto the call stack, copies each argument into the matching parameter, runs the body, and when it hits return, pops the frame and hands the value back to the caller, right in the middle of whatever expression made the call.

·

two things worth noticing. parameters are copies: square changing its x could never touch a in the caller (that's pass-by-value, and it holds for objects too, in a way that surprises people). and locals are gone the instant the method returns, which is why a method can't hand you a reference to its local int, only the value.

overloading

two methods can have the same name as long as their parameter lists differ: println(int), println(String), println(double)... that's why one println can print anything. the compiler picks which one to call from the types of the arguments, at compile time.

when more than one could fit, java searches in three rounds and stops at the first round that finds a match:

1. phase 1: exact types, widening (int → long), subclasses. no boxing, no varargs.
2. phase 2: also allow boxing and unboxing (int ↔ Integer).
3. phase 3: also allow varargs.

within a round, the most specific candidate wins (int beats long beats double, Integer beats Object).

static String m(long x) { ... }
static String m(Integer x) { ... }
static String m(int... x) { ... }
m(5);  // int

static String m(long x)    { return "long"; }
static String m(Integer x) { return "Integer"; }
 
IO.println(m(5));

the return type plays no part in choosing, which is why you can't overload on it:

int f(int a) { return 1; }
long f(int a) { return 2; }

error: method f(int) is already defined. same name, same parameter types, same signature, whatever they return.

varargs

put ... after the last parameter's type and the method accepts any number of arguments of that type, including zero. inside the method, it's simply an array:

void main() {
    IO.println(sum() + " " + sum(5) + " " + sum(1, 2, 3) + " " + sum(new int[] {4, 5}));
}
 
int sum(int... nums) {
    int total = 0;
    for (int n : nums) total += n;
    return total;
}

0 5 6 9

only the last parameter can be varargs, and there can be just one. String.format(String format, Object... args) and List.of(E... elements) are the varargs methods you'll meet most.