Method Overloading

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

import java.util.*;
 
public class ListRemovePitfall {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        
        System.out.println("Before: " + numbers);  // [1, 2, 3]
        
        // Intent: remove the value 2
        numbers.remove(2);  // WRONG! This removes index 2, not value 2!
        
        System.out.println("After: " + numbers);   // [1, 2]  — value 3 was removed!
        
        // The List interface has two remove methods:
        // E remove(int index)      — removes by position
        // boolean remove(Object o) — removes by value
        
        // When you pass an int literal, it matches remove(int) exactly
        // (no autoboxing needed), so the index version is called!
        
        // Correct approaches:
        numbers.add(3);  // restore the list
        
        numbers.remove(Integer.valueOf(2));  // Explicit boxing → remove by value
        // OR
        numbers.remove((Integer) 2);         // Cast to force overload selection
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

public class UnboxingNPE {
    
    void process(int value) {
        System.out.println("Primitive: " + value);
    }
    
    void process(Object value) {
        System.out.println("Object: " + value);
    }
    
    public static void main(String[] args) {
        UnboxingNPE demo = new UnboxingNPE();
        
        Integer nullableValue = null;
        
        // Which overload is called?
        demo.process(nullableValue);  // Calls process(Object) — safe, prints "Object: null"
        
        // But what if we had these overloads instead:
    }
}
 
class DangerousOverloads {
    void process(int value) {
        System.out.println("Primitive: " + value);
    }
    
    void process(String value) {
        System.out.println("String: " + value);
    }
    
    public static void main(String[] args) {
        DangerousOverloads demo = new DangerousOverloads();
        
        Integer nullableValue = null;
        
        // demo.process(nullableValue);  // COMPILE ERROR! Neither int nor String matches!
        
        // But if we force it:
        demo.process((int) nullableValue);  // NPE! Unboxing null throws immediately!
        
        // The real danger is when the overload selection causes unboxing:
    }
}
 
class SubtleNPE {
    void calculate(int x, int y) {
        System.out.println("Result: " + (x + y));
    }
    
    void calculate(Integer x, Integer y) {
        System.out.println("Result: " + (x + y));  // NPE if either is null!
    }
    
    public static void main(String[] args) {
        SubtleNPE demo = new SubtleNPE();
        
        Integer a = 5;
        Integer b = null;
        
        demo.calculate(a, b);  // Calls calculate(Integer, Integer)
        // Then x + y causes unboxing of null b → NPE inside the method!
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

public class TypeConfusionDemo {
    
    void process(Object obj)  { System.out.println("Object: " + obj.getClass()); }
    void process(String str)  { System.out.println("String: " + str); }
    void process(Integer num) { System.out.println("Integer: " + num); }
    
    public static void main(String[] args) {
        TypeConfusionDemo demo = new TypeConfusionDemo();
        
        // Direct calls work as expected
        demo.process("hello");   // String: hello
        demo.process(42);        // Integer: 42
        
        // But through a collection of Objects...
        List<Object> items = Arrays.asList("hello", 42, new Object());
        
        for (Object item : items) {
            demo.process(item);  // ALL call process(Object)!
        }
        
        // Output:
        // Object: class java.lang.String
        // Object: class java.lang.Integer  
        // Object: class java.lang.Object
        
        // Even though items[0] IS a String at runtime,
        // the compile-time type of 'item' is Object,
        // so process(Object) is called every time!
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

// Broken attempt at visitor using overloading
interface Shape { }
class Circle implements Shape { }
class Rectangle implements Shape { }
 
class ShapeProcessor {
    void process(Circle c)    { System.out.println("Processing circle"); }
    void process(Rectangle r) { System.out.println("Processing rectangle"); }
    void process(Shape s)     { System.out.println("Unknown shape"); }
}
 
class BrokenVisitor {
    public static void main(String[] args) {
        ShapeProcessor processor = new ShapeProcessor();
        List<Shape> shapes = Arrays.asList(new Circle(), new Rectangle());
        
        for (Shape shape : shapes) {
            processor.process(shape);  // Both call process(Shape)!
        }
        // Output:
        // Unknown shape
        // Unknown shape
        
        // This is NOT how the Visitor pattern works!
    }
}
 
// Correct Visitor implementation:
interface ShapeVisitor {
    void visit(Circle circle);
    void visit(Rectangle rectangle);
}
 
interface VisitableShape {
    void accept(ShapeVisitor visitor);
}
 
class CircleV implements VisitableShape {
    public void accept(ShapeVisitor visitor) { 
        visitor.visit(this);  // "this" has compile-time type Circle
    }
}
 
class RectangleV implements VisitableShape {
    public void accept(ShapeVisitor visitor) { 
        visitor.visit(this);  // "this" has compile-time type Rectangle
    }
}
 
class ProcessingVisitor implements ShapeVisitor {
    public void visit(Circle c)    { System.out.println("Processing circle"); }
    public void visit(Rectangle r) { System.out.println("Processing rectangle"); }
}
 
// Now it works because accept() uses override (runtime dispatch)
// to call the right visit() with the correct compile-time type.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

// DANGEROUS: Inconsistent overloads
public class BadFormatter {
    
    // Formats with ISO 8601 format
    public String format(Date date) {
        return new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss").format(date);
    }
    
    // Formats with US locale format — INCONSISTENT!
    public String format(LocalDateTime dateTime) {
        return dateTime.format(DateTimeFormatter.ofPattern("MM/dd/yyyy h:mm a"));
    }
}
 
// The caller expects same format regardless of input type:
// formatter.format(date)          → "2024-01-15T10:30:00"
// formatter.format(localDateTime) → "01/15/2024 10:30 AM"  ← Surprise!
 
// CORRECT: Consistent behavior
public class GoodFormatter {
    private static final DateTimeFormatter ISO_FORMAT = 
        DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss");
    
    public String format(Date date) {
        return format(date.toInstant()
            .atZone(ZoneId.systemDefault())
            .toLocalDateTime());
    }
    
    public String format(LocalDateTime dateTime) {
        return ISO_FORMAT.format(dateTime);
    }
    
    // Both delegate to LocalDateTime version with same formatter
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

// DANGEROUS: Dramatically different side effects
public class DangerousCache {
    private Map<String, Object> cache = new HashMap<>();
    
    // Returns cached value or null
    public Object get(String key) {
        return cache.get(key);
    }
    
    // Returns cached value or STORES AND RETURNS the default!
    public Object get(String key, Object defaultValue) {
        if (!cache.containsKey(key)) {
            cache.put(key, defaultValue);  // SIDE EFFECT!
        }
        return cache.get(key);
    }
}
 
// User expects:
// cache.get("key")           → null (key not present)
// cache.get("key", "default") → "default" (using default)
// cache.get("key")           → null (still not present)  ← WRONG!
 
// Actual behavior:
// cache.get("key")           → null
// cache.get("key", "default") → "default" (and stores it!)
// cache.get("key")           → "default" (now it's there!)
 
// BETTER: Different names for different behaviors
public class SafeCache {
    private Map<String, Object> cache = new HashMap<>();
    
    public Object get(String key) {
        return cache.get(key);
    }
    
    public Object getOrDefault(String key, Object defaultValue) {
        return cache.getOrDefault(key, defaultValue);  // No storing!
    }
    
    public Object computeIfAbsent(String key, Supplier<Object> supplier) {
        return cache.computeIfAbsent(key, k -> supplier.get());  // Clear contract!
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// Ambiguity-prone: parallel hierarchies
class Renderer {
    void render(Serializable data) { /* ... */ }
    void render(Comparable<?> data) { /* ... */ }
    
    // String implements BOTH Serializable AND Comparable<String>!
    // render("hello");  // COMPILE ERROR: ambiguous
}
 
// Many core classes implement multiple interfaces:
// String: Serializable, Comparable, CharSequence
// Integer: Serializable, Comparable, Number
// ArrayList: Serializable, Cloneable, Iterable, Collection, List
 
// SOLUTION: Use more specific types or different names
class SafeRenderer {
    void renderSerializable(Serializable data) { /* ... */ }
    void renderComparable(Comparable<?> data) { /* ... */ }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

class VarargsTrap {
    void log(String message) { 
        System.out.println("Simple: " + message); 
    }
    
    void log(String format, Object... args) { 
        System.out.println("Formatted: " + String.format(format, args)); 
    }
    
    public static void main(String[] args) {
        VarargsTrap logger = new VarargsTrap();
        
        logger.log("Hello");  // Which one?
        // Calls log(String) — exact match beats varargs
        
        logger.log("Hello %s", "World");  // log(String, Object...)
        
        // But what about:
        logger.log("Hello %s");  // Calls log(String)!
        // If passed to printf, would crash expecting an argument
        
        // User intent was probably to format, but no args = simple version
    }
}
 
// More dangerous:
class VarargsNull {
    void process(String... strings) { 
        System.out.println("Strings: " + Arrays.toString(strings)); 
    }
    
    void process(Integer... integers) { 
        System.out.println("Integers: " + Arrays.toString(integers)); 
    }
    
    public static void main(String[] args) {
        VarargsNull demo = new VarargsNull();
        
        // demo.process(null);  // COMPILE ERROR: ambiguous!
        
        demo.process((String[]) null);   // Works but prints "Strings: null"
        demo.process((Integer[]) null);  // Works but prints "Integers: null"
        
        demo.process();  // COMPILE ERROR: ambiguous with no args!
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

// ALWAYS problematic: crossed parameters
class CrossedParams {
    void transfer(Account from, SavingsAccount to) { /* ... */ }
    void transfer(SavingsAccount from, Account to) { /* ... */ }
    
    // SavingsAccount extends Account
    // When both are SavingsAccount, neither overload is more specific!
    
    SavingsAccount savings1 = new SavingsAccount();
    SavingsAccount savings2 = new SavingsAccount();
    
    // transfer(savings1, savings2);  // COMPILE ERROR: ambiguous
}
 
// NEVER do this:
void method(Parent a, Child b) { }
void method(Child a, Parent b) { }
 
// With two Child arguments, neither is more specific than the other.
 
// SOLUTION: Single method with runtime type checking if needed
class SafeTransfer {
    void transfer(Account from, Account to) {
        // Handle all combinations in one method
        // Use instanceof if behavior differs by subtype
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// Version 1.0 of the library
public class StringUtils_v1 {
    public static void log(Object message) {
        System.out.println("[LOG] " + message);
    }
}
 
// Client code
// StringUtils_v1.log("Hello");  // Calls log(Object)
 
// Version 2.0 adds a new overload
public class StringUtils_v2 {
    public static void log(Object message) {
        System.out.println("[LOG] " + message);
    }
    
    public static void log(String message) {
        // New: logs with timestamp
        System.out.println("[LOG " + Instant.now() + "] " + message);
    }
}
 
// Client code (unchanged)
// StringUtils_v2.log("Hello");  // Now calls log(String)!
// Output SILENTLY CHANGED from "[LOG] Hello" to "[LOG 2024-01-15T...] Hello"
 
// The client's behavior changed without them modifying their code.
// No compile error, no warning—just different runtime behavior.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// Version 1.0
public class DataProcessor_v1 {
    public void process(Number num) { /* ... */ }
}
 
// Client code compiles fine:
// processor.process(null);  // Calls process(Number)
 
// Version 2.0 adds overload
public class DataProcessor_v2 {
    public void process(Number num) { /* ... */ }
    public void process(String str) { /* ... */ }  // NEW!
}
 
// Client code NOW FAILS TO COMPILE:
// processor.process(null);  // ERROR: ambiguous!
// null matches both Number and String equally.
 
// The client must update their code:
// processor.process((Number) null);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

// This seems reasonable but has subtle issues
public class Repository<T> {
    
    public void save(T entity) { /* save single entity */ }
    
    public void save(List<T> entities) { /* save multiple */ }
    
    // These work fine for Repository<User>
    // save(user);        → save(T)
    // save(userList);    → save(List<T>)
}
 
// But what about Repository<List<String>>?
Repository<List<String>> listRepo = new Repository<>();
List<String> single = Arrays.asList("a", "b");
List<List<String>> multiple = Arrays.asList(single, Arrays.asList("c"));
 
// listRepo.save(single);  // Which overload? 
// T = List<String>, so save(T) expects List<String>
// save(List<T>) expects List<List<String>>
// Both match! Compiler picks save(T) as more specific.
 
// But the design is confusing—user might expect batch behavior.
 
// SAFER: Use clearly different method names
public class SafeRepository<T> {
    public void saveOne(T entity) { /* ... */ }
    public void saveAll(Collection<T> entities) { /* ... */ }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

// TOO MANY OVERLOADS: Reader can't quickly understand calls
public class Request {
    // 15+ overloads make this API exhausting to use
    public Response send();
    public Response send(Duration timeout);
    public Response send(Headers headers);
    public Response send(Body body);
    public Response send(Headers headers, Duration timeout);
    public Response send(Body body, Duration timeout);
    public Response send(Headers headers, Body body);
    public Response send(Headers headers, Body body, Duration timeout);
    public Response send(Headers headers, Body body, Duration timeout, RetryConfig retry);
    // ... imagine more combinations
}
 
// Calling code becomes a puzzle:
Response r = request.send(headers, body, timeout);
// Wait, which overload is this? Are there more parameters I should consider?
// What defaults are being applied for the omitted parameters?
 
// CLEANER: Builder pattern for complex configuration
public class Request {
    public static RequestBuilder builder() {
        return new RequestBuilder();
    }
    
    public Response send() {
        return execute();
    }
}
 
// Self-documenting calls:
Response r = Request.builder()
    .headers(headers)
    .body(body)
    .timeout(Duration.ofSeconds(30))
    .retry(RetryConfig.exponential(3))
    .build()
    .send();
    
// Every option is explicit and labeled.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

public class AmbiguousAPI {
    // The meaning of the second parameter depends on its type!
    void configure(String key, int value) { 
        // Sets a numeric configuration
        System.out.println("Setting " + key + " to number " + value);
    }
    
    void configure(String key, String value) { 
        // Sets a string configuration
        System.out.println("Setting " + key + " to string " + value);
    }
    
    void configure(String key, boolean value) { 
        // Enables or disables a feature
        System.out.println((value ? "Enabling" : "Disabling") + " " + key);
    }
    
    void configure(String key, Duration value) {
        // Sets a timeout
        System.out.println("Setting " + key + " timeout to " + value);
    }
}
 
// Reading this code requires type inspection:
config.configure("cache.size", 1000);     // numeric
config.configure("app.name", "MyApp");    // string
config.configure("debug.mode", true);     // boolean toggle
config.configure("request.timeout", Duration.ofSeconds(30));  // timeout
 
// CLEARER: Named methods
public class ExplicitAPI {
    void setNumber(String key, int value) { /* ... */ }
    void setString(String key, String value) { /* ... */ }
    void setEnabled(String key, boolean enabled) { /* ... */ }
    void setTimeout(String key, Duration timeout) { /* ... */ }
}
 
// Now the intent is obvious without checking parameter types:
config.setNumber("cache.size", 1000);
config.setEnabled("debug.mode", true);
config.setTimeout("request.timeout", Duration.ofSeconds(30));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

/**
 * Template for safe overloading design.
 */
public class SafeOverloadingTemplate {
    
    // 1. Simple convenience overloads delegate to the master
    public Result process(Input input) {
        return process(input, Options.defaults());
    }
    
    public Result process(Input input, Duration timeout) {
        return process(input, Options.defaults().withTimeout(timeout));
    }
    
    // 2. Master implementation: all logic lives here
    /**
     * The master process method. All other overloads delegate here.
     * 
     * @param input the input to process (must not be null)
     * @param options processing options (must not be null)
     * @return the processing result
     * @throws NullPointerException if input or options is null
     */
    public Result process(Input input, Options options) {
        Objects.requireNonNull(input, "input must not be null");
        Objects.requireNonNull(options, "options must not be null");
        
        // Actual implementation
        return doProcess(input, options);
    }
    
    // 3. For type variants, document the equivalence
    /**
     * Convenience overload accepting String path.
     * Equivalent to: {@code process(new FileInput(path))}
     */
    public Result process(String path) {
        return process(new FileInput(path));
    }
    
    /**
     * Convenience overload accepting Path.
     * Equivalent to: {@code process(new FileInput(path.toString()))}
     */
    public Result process(Path path) {
        return process(path.toString());
    }
    
    // 4. Private implementation detail
    private Result doProcess(Input input, Options options) {
        // ...
    }
}