Overloading, Objects as Parameters & Recursion

Before we start

Why this matters

Outline · Lectures 7–8

Topics in this chapter

Select a topic to jump to the slide that explains it.

1. Method overloading
2. Constructor overloading
3. Passing objects as parameters
4. Returning objects
5. Recursion

Concept 1 of 5

Method overloading

class Calc {
    int    add(int a, int b)          { return a + b; }
    int    add(int a, int b, int c)   { return a + b + c; }
    double add(double a, double b)    { return a + b; }
    String add(String a, String b)    { return a + b; }
}
Calc c = new Calc();
c.add(2, 3);        // 5      → add(int, int)
c.add(2, 3, 4);     // 9      → add(int, int, int)
c.add(2.5, 1);      // 3.5    → add(double, double)
c.add("OO", "P");   // "OOP"  → add(String, String)

Interactive

Which overload runs?

Concept 2 of 5

Constructor overloading and this(...)

class Box {
    double w, h, d;
    Box() {                    // unit cube
        this(1, 1, 1);
    }
    Box(double side) {         // cube
        this(side, side, side);
    }
    Box(double w, double h, double d) {
        this.w = w; this.h = h; this.d = d;
    }
}

Step through the code

Trace: constructor chaining with this(...)

Watch the call stack grow as one constructor hands over to another.

Step through the code

Trace: constructor chaining with this(...) (cont.)

Concept 3 of 5

Passing arguments: always by value

• Java copies the value of each argument into the parameter.
• For a primitive, the value is the number itself: changing the parameter never affects the caller.
• For an object, the value is a reference: the method can change the object’s fields through it…
• …but assigning a new object to the parameter only changes the method’s copy of the arrow.

Step through the code

Trace: what can a method change?

Three methods try to change the caller’s data. Before stepping, predict the final line: k and p.x.

Step through the code

Trace: what can a method change? (cont.)

Code example

Returning objects

1/2 + 1/3 = 5/6
true

• A method can create an object and return its reference; the object outlives the method call.
• Methods that return objects can be chained: a.add(b).add(c).
• Passing another object of the same class (o) lets a method read its private fields, because access is checked per class.

Concept 4 of 5

Recursion

Recursion

static int fact(int n) {
    if (n <= 1) return 1;          // base case
    return n * fact(n - 1);        // recursive case
}

static int fib(int n) {
    if (n < 2) return n;
    return fib(n - 1) + fib(n - 2);
}

• A recursive method calls itself on a smaller problem.
• Every recursion needs a base case that stops it; without one you get StackOverflowError.
• Each call gets its own stack frame with its own n.

Step through the code

Trace: factorial on the call stack

The stack grows with every call until the base case, then the results multiply back up as the frames return.

Step through the code

Trace: factorial on the call stack (cont.)

Code example

More recursive methods

19 1024 avaj
disk 1: A -> B
disk 2: A -> C
disk 1: B -> C

Step through the code

Trace: Tower of Hanoi on the call stack

Each call gets its own frame with its own n, from, to and via. Watch the stack grow to the base case and shrink again.

Step through the code

Trace: Tower of Hanoi on the call stack (cont.)

Concept 5 of 5

Recursion or iteration?

Worked example 1 of 3

Worked example 1

Worked example 2 of 3

Worked example 2

Worked example 3 of 3

Worked example 3

static int count(String s, char c) {
    if (s.isEmpty()) return 0;
    return (s.charAt(0) == c ? 1 : 0) + count(s.substring(1), c);
}
// count("banana", 'a') → 3

Practice

Practice (1 of 2)

Try each one on paper first, then check your answer.

Time() { this(0, 0); }
Time(int h) { this(h, 0); }
Time(int h, int m) { this.h = h; this.m = m; }

Practice

Practice (2 of 2)

Try each one on paper first, then check your answer.

static int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }

Point midpoint(Point p) {
    return new Point((x + p.x) / 2, (y + p.y) / 2);
}

Check yourself

Quiz

Summary

Summary

• Overloading = same name, different parameter lists; the compiler picks at compile time (exact → widening → boxing → varargs).
• Overloaded constructors can delegate with this(...) as the first statement.
• Java is always pass-by-value: primitives are copied; for objects the reference is copied, so fields can change but reassignment cannot escape.
• Methods can create and return objects, enabling chaining like a.add(b).add(c).
• Recursion needs a base case and a smaller subproblem; each call has its own stack frame.