Compile-time Polymorphism

// ── Compile-time polymorphism through method overloading: ────────────
public class DataFormatter {

    // Same conceptual operation — format — four different implementations:
    public String format(int value) {
        return String.format("%,d", value);           // 1,234,567
    }

    public String format(double value) {
        return String.format("%.2f", value);          // 3.14
    }

    public String format(boolean value) {
        return value ? "Yes" : "No";                  // Yes / No
    }

    public String format(String value) {
        if (value == null) return "(null)";
        return """ + value.trim() + """;            // "hello"
    }

    public String format(double value, int decimalPlaces) {
        return String.format("%." + decimalPlaces + "f", value);
    }
}

// ── Compiler resolves each call at compile time: ──────────────────────
DataFormatter fmt = new DataFormatter();

String r1 = fmt.format(1234567);       // → format(int)
String r2 = fmt.format(3.14159);       // → format(double)
String r3 = fmt.format(true);          // → format(boolean)
String r4 = fmt.format("  hello  ");   // → format(String)
String r5 = fmt.format(3.14159, 4);    // → format(double, int)

System.out.println(r1);  // 1,234,567
System.out.println(r2);  // 3.14
System.out.println(r3);  // Yes
System.out.println(r4);  // "hello"
System.out.println(r5);  // 3.1416

// ── Resolution happens at compile time — bytecode shows the decision: ──
// The compiled bytecode for fmt.format(1234567) contains a direct
// invokevirtual reference to format(int) — not a generic dispatch.
// The choice is baked into the class file.

// ── Phase 1: exact match — always wins: ──────────────────────────────
public class Resolver {
    public void process(int n)    { System.out.println("int: "    + n); }
    public void process(long n)   { System.out.println("long: "   + n); }
    public void process(double n) { System.out.println("double: " + n); }
    public void process(String s) { System.out.println("String: " + s); }
    public void process(Object o) { System.out.println("Object: " + o); }
}

Resolver r = new Resolver();
r.process(42);          // exact match → process(int)
r.process(42L);         // exact match → process(long)
r.process(42.0);        // exact match → process(double)
r.process("hello");     // exact match → process(String)

// ── Phase 2: widening primitive conversions: ──────────────────────────
r.process((short) 10);  // short widens to int → process(int)
r.process(3.14f);       // float widens to double → process(double)
// No process(short) or process(float) exists, so widening applies.

// ── Widening takes priority over boxing: ──────────────────────────────
public class BoxingVsWidening {
    public void show(long n)    { System.out.println("long: "    + n); }
    public void show(Integer n) { System.out.println("Integer: " + n); }
}

BoxingVsWidening bvw = new BoxingVsWidening();
bvw.show(42);   // int — widens to long (Phase 2), NOT boxed to Integer (Phase 3)
// Output: long: 42

// ── Phase 3: boxing/unboxing: ─────────────────────────────────────────
public class BoxingExample {
    public void show(int n)     { System.out.println("int: "    + n); }
    public void show(Integer n) { System.out.println("Integer: " + n); }
}

BoxingExample be = new BoxingExample();
be.show(42);             // exact match → show(int)
be.show(Integer.valueOf(42)); // exact match → show(Integer)

// ── Ambiguity — null matches multiple reference types: ────────────────
public class Ambiguous {
    public void call(String s)  { System.out.println("String"); }
    public void call(Integer n) { System.out.println("Integer"); }
}

Ambiguous amb = new Ambiguous();
// amb.call(null);  // COMPILE ERROR — null matches both String and Integer
                    // neither is more specific than the other

amb.call((String)  null);   // ✓ explicit cast resolves ambiguity → String
amb.call((Integer) null);   // ✓ explicit cast resolves ambiguity → Integer

// ── Subtype specificity: ──────────────────────────────────────────────
public class Specificity {
    public void show(Object o)  { System.out.println("Object: " + o); }
    public void show(String s)  { System.out.println("String: " + s); }
}

Specificity sp = new Specificity();
sp.show("hello");   // String is more specific than Object → show(String)
sp.show(42);        // 42 is Integer, boxes to Object → show(Object)

// ── Constructor overloading — compile-time resolution: ───────────────
public class Connection {
    private final String host;
    private final int    port;
    private final boolean secure;
    private final int    timeoutMs;

    // Four constructors — compiler picks based on argument types:
    public Connection(String host, int port, boolean secure, int timeoutMs) {
        this.host      = host;
        this.port      = port;
        this.secure    = secure;
        this.timeoutMs = timeoutMs;
    }

    public Connection(String host, int port, boolean secure) {
        this(host, port, secure, 30_000);
    }

    public Connection(String host, int port) {
        this(host, port, true);
    }

    public Connection(String host) {
        this(host, 443);
    }

    @Override
    public String toString() {
        return (secure ? "https" : "http") + "://" + host + ":" + port +
               " (timeout=" + timeoutMs + "ms)";
    }
}

// ── Each new call resolved at compile time: ───────────────────────────
Connection c1 = new Connection("api.example.com");
// Compiler resolves: Connection(String) — at compile time
System.out.println(c1);  // https://api.example.com:443 (timeout=30000ms)

Connection c2 = new Connection("api.example.com", 8080);
// Compiler resolves: Connection(String, int) — at compile time
System.out.println(c2);  // https://api.example.com:8080 (timeout=30000ms)

Connection c3 = new Connection("api.example.com", 8080, false, 5000);
// Compiler resolves: Connection(String, int, boolean, int) — at compile time
System.out.println(c3);  // http://api.example.com:8080 (timeout=5000ms)

// ── The key difference in a single example: ──────────────────────────
public class Processor {
    // Overloaded methods — compile-time resolution:
    public void process(Animal a) { System.out.println("Processing Animal"); }
    public void process(Dog d)    { System.out.println("Processing Dog");    }
}

public class Animal {
    public String speak() { return "..."; }          // overridable
}

public class Dog extends Animal {
    @Override
    public String speak() { return "Woof!"; }         // overriding
}

Animal animal = new Dog();   // reference type: Animal, object type: Dog

Processor p = new Processor();

// OVERLOADING — resolved at COMPILE TIME based on REFERENCE type:
p.process(animal);           // "Processing Animal" — compiler sees Animal
// Even though the object is a Dog, the reference type is Animal.
// Compiler picks process(Animal) at compile time.

// OVERRIDING — resolved at RUNTIME based on OBJECT type:
System.out.println(animal.speak());   // "Woof!" — Dog's implementation
// JVM looks at the actual object (Dog) at runtime.
// Dog.speak() overrides Animal.speak() — Dog's version runs.

// ── Summary table: ────────────────────────────────────────────────────
//
//                    OVERLOADING            OVERRIDING
// ─────────────────  ─────────────────────  ─────────────────────
// Also called        Static / compile-time  Dynamic / runtime
// Resolved by        Compiler               JVM at runtime
// Based on           Reference type         Object (actual) type
// Parameter list     Must differ            Must be same
// Return type        Can be different       Same or covariant
// Inheritance        Same class             Across class hierarchy
// @Override          Not applicable         Should always use
// Keyword            none                   @Override (annotation)
// Performance        Slightly faster        vtable lookup (optimised)
// Use case           API convenience        Behaviour specialisation