Method Overloading vs Overriding

public class Priority {
    void test(long x)      { System.out.println("widening"); }   // 1st priority
    void test(Integer x)   { System.out.println("boxing"); }     // 2nd priority
    void test(int... x)    { System.out.println("varargs"); }    // 3rd priority

    public static void main(String[] args) {
        new Priority().test(5);  // prints "widening"
    }
}

public class Calculator {
    // Different number of parameters
    int add(int a, int b) { return a + b; }
    int add(int a, int b, int c) { return a + b + c; }

    // Different parameter types
    double add(double a, double b) { return a + b; }

    // Different parameter order
    String format(String name, int id) { return id + ":" + name; }
    String format(int id, String name) { return name + "#" + id; }

    // Static methods CAN be overloaded
    static void print(int x) { System.out.println("int: " + x); }
    static void print(String x) { System.out.println("str: " + x); }
}

class Parent {
    protected void show() { }
}

class Child extends Parent {
    @Override
    public void show() { }     // OK: public > protected (wider)

    // @Override
    // private void show() { } // COMPILE ERROR: cannot reduce visibility
}

class Parent {
    void read() throws IOException { }
}

class Child extends Parent {
    @Override
    void read() throws FileNotFoundException { }  // OK: narrower (subtype of IOException)

    // @Override
    // void read() throws Exception { }  // COMPILE ERROR: broader checked exception
}

class Animal {
    void speak() { System.out.println("Animal speaks"); }
    void eat(Object food) { System.out.println("Animal eats object"); }
    void eat(String food) { System.out.println("Animal eats " + food); } // overloaded
}

class Dog extends Animal {
    @Override
    void speak() { System.out.println("Dog barks"); }  // overridden
}

public class Main {
    public static void main(String[] args) {
        Animal a = new Dog();  // Reference: Animal, Object: Dog

        // RUNTIME dispatch (overriding) — calls Dog.speak()
        a.speak();  // "Dog barks"

        // COMPILE-TIME dispatch (overloading) — compiler sees ref type Animal
        Object food = "Bone";
        a.eat(food);  // "Animal eats object" (NOT "Animal eats Bone")
        // Compiler resolves overload using reference type of 'food' which is Object
    }
}

class Animal {
    Animal create() {
        return new Animal();
    }
}

class Dog extends Animal {
    @Override
    Dog create() {     // Covariant return: Dog is subtype of Animal
        return new Dog();
    }
}

// Benefit: no casting needed
Dog d = new Dog().create();  // returns Dog directly, no cast

class Parent {
    Number getValue() { return 42; }
}

class Child extends Parent {
    @Override
    Integer getValue() { return 42; }  // OK: Integer extends Number
}

class Parent {
    static void greet() { System.out.println("Hello from Parent"); }
    void hello()        { System.out.println("Parent instance"); }
}

class Child extends Parent {
    static void greet() { System.out.println("Hello from Child"); }  // HIDING, not overriding
    @Override
    void hello()        { System.out.println("Child instance"); }    // TRUE override
}

public class Test {
    public static void main(String[] args) {
        Parent obj = new Child();

        obj.greet();  // "Hello from Parent" (static — reference type wins)
        obj.hello();  // "Child instance"    (instance — object type wins)
    }
}

class Shape {
    void draw() { System.out.println("Drawing Shape"); }
    void draw(String color) { System.out.println("Shape in " + color); }
}

class Circle extends Shape {
    @Override
    void draw() { System.out.println("Drawing Circle"); }
    void draw(String color, int radius) { System.out.println("Circle r=" + radius); }
}

Shape s = new Circle();
s.draw();              // "Drawing Circle"  (override — object type)
s.draw("red");         // "Shape in red"    (no override in Circle for this signature)
// s.draw("red", 5);  // COMPILE ERROR: Shape has no draw(String, int)

class Demo {
    void test(Object o)  { System.out.println("Object"); }
    void test(String s)  { System.out.println("String"); }
    void test(Integer i) { System.out.println("Integer"); }

    public static void main(String[] args) {
        new Demo().test(null);
        // COMPILE ERROR: ambiguous — String and Integer are both subclasses of Object
        // but neither is more specific than the other

        // Fix:
        new Demo().test((String) null);  // "String"
    }
}

class Animal {
    void feed(long amount) { System.out.println("Animal fed: " + amount); }
}

class Dog extends Animal {
    @Override
    void feed(long amount) { System.out.println("Dog fed: " + amount); }

    // This is an OVERLOAD, not an override!
    void feed(int amount) { System.out.println("Dog int fed: " + amount); }
}

Animal a = new Dog();
a.feed(10);    // "Dog fed: 10"  -- int widens to long, then override kicks in
// Compiler: ref type is Animal, only sees feed(long). int 10 widens to long.
// Runtime: object is Dog, so Dog.feed(long) executes.

Dog d = new Dog();
d.feed(10);    // "Dog int fed: 10" -- exact match feed(int) preferred over widening

class Parent {
    private void secret() { System.out.println("Parent secret"); }

    void callSecret() { secret(); }  // calls Parent.secret() always
}

class Child extends Parent {
    // This is NOT an override — Parent.secret() is invisible to Child
    private void secret() { System.out.println("Child secret"); }
}

new Child().callSecret();  // "Parent secret" (private methods bind at compile time)

class Factory {
    Object create(String type) { return new Object(); }
    Factory build() { return new Factory(); }
}

class WidgetFactory extends Factory {
    @Override
    String create(String type) { return "Widget"; }  // Covariant: String extends Object

    @Override
    WidgetFactory build() { return new WidgetFactory(); }  // Covariant return
}

Factory f = new WidgetFactory();
Object o = f.create("x");   // Returns "Widget" (runtime dispatch)
Factory b = f.build();       // Returns WidgetFactory instance (runtime dispatch)