Methods & Overloading

Method Anatomy

public static int add(int a, int b) {
    return a + b;
}
//  ^      ^   ^   ^   ^      ^      ^
//        └ method body
//        └ parameter list
//     └ method name
//     └ return type (use void for no return)
//     └ "static" — belongs to the class, not an instance
//  |      └ access modifier
//  └ optional access scope

Access Modifiers

public class Counter {
    static int totalCounters = 0;   // shared across all instances
    int count;                       // per-instance
    public Counter()      { totalCounters++; }
    public void inc()      { count++; }
    public int  get()      { return count; }
    public static int howMany() { return totalCounters; }
}

Parameters — Pass-by-Value (Always)

Java has only pass-by-value. But for reference types, the *value being passed* IS a reference (a pointer to the object). So:

static void reassign(int[] arr) {
    arr = new int[]{99};   // local variable now points elsewhere
}
static void mutate(int[] arr) {
    arr[0] = 99;           // modifies the SAME array the caller has
}
public static void main(String[] a) {
    int[] x = {1, 2, 3};
    reassign(x);
    System.out.println(x[0]);   // 1   (caller's reference unchanged)
    mutate(x);
    System.out.println(x[0]);   // 99  (caller's array WAS mutated)
}

> Rule of thumb: you can't change what the caller's variable POINTS to, but you can mutate the object behind that reference.

Overloading

Multiple methods with the same name but different parameter lists:

public class Printer {
    public static void show(int x)        { System.out.println("int " + x); }
    public static void show(double x)     { System.out.println("double " + x); }
    public static void show(String x)     { System.out.println("string " + x); }
    public static void show(int x, int y) { System.out.println("two ints " + x + ", " + y); }
}

Resolution rules (the compiler picks the best fit):

1. Exact match wins (show(5) → int overload). 2. Then widening primitives (int → long → double). 3. Then autoboxing (int → Integer). 4. Then varargs.

> Return type alone CANNOT distinguish overloads — the compiler refuses.

Varargs (Variable Arguments)

public static String join(String sep, String... parts) {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < parts.length; i++) {
        if (i > 0) sb.append(sep);
        sb.append(parts[i]);
    }
    return sb.toString();
}
join(", ", "a", "b", "c");   // "a, b, c"

Rules:

• The varargs parameter must be last.
• Inside the method it's just an array (String[]).
• You can pass an actual array.

Default Parameters? Use Overloading

Java has no default parameters. The idiomatic substitute is overloading:

public static String greet(String name)            { return greet(name, "Hello"); }
public static String greet(String name, String hi) { return hi + ", " + name + "!"; }
greet("Asha");              // "Hello, Asha!"
greet("Asha", "Welcome");   // "Welcome, Asha!"

Recursion

public static int fib(int n) {
    if (n < 2) return n;
    return fib(n - 1) + fib(n - 2);     // O(2^n) — slow
}

For deep recursion, use memoisation or convert to iteration. The default JVM stack is ~512 KB → roughly 10⁴ frames before StackOverflowError.

return and void

• A non-void method must return on every code path.
• void methods can use return; (no value) to exit early.

public static int abs(int n) {
    if (n < 0) return -n;
    return n;       // every path covered
}
public static void greet(String name) {
    if (name == null) return;
    System.out.println("Hi " + name);
}

Method References (Quick Preview)

Once you know lambdas, you can pass methods as values:

import java.util.function.*;
Function<Integer, Integer> sq = MathUtil::square;
sq.apply(5);            // 25

Full coverage in the lambdas topic.

Naming & Style

• camelCase: computeTotal, getUserById.
• Verbs for actions: save, delete, render.
• Booleans as isXxx / hasXxx: isEmpty(), hasNext().
• Keep methods small — under ~30 lines is a good guideline.

Common Mistakes

You can now organise code into reusable methods. Next: strings — Java's most-used object.