Java Polymorphism

public class MethodOverloading1 {

    // Same naam "calculate" - alag parameters
    // STATIC POLYMORPHISM!

    // 1. Two integers
    static int calculate(int a, int b) {
        System.out.println("calculate(int, int)");
        return a + b;
    }

    // 2. Three integers
    static int calculate(int a, int b, int c) {
        System.out.println("calculate(int, int, int)");
        return a + b + c;
    }

    // 3. Two doubles
    static double calculate(double a, double b) {
        System.out.println("calculate(double, double)");
        return a + b;
    }

    // 4. String and int (order 1)
    static String calculate(String s, int n) {
        System.out.println("calculate(String, int)");
        return s.repeat(n);
    }

    // 5. Int and String (order 2) - ORDER matters!
    static String calculate(int n, String s) {
        System.out.println("calculate(int, String)");
        return n + ": " + s;
    }

    // 6. Double and int
    static double calculate(double d, int n) {
        System.out.println("calculate(double, int)");
        return d * n;
    }

    public static void main(String[] args) {

        System.out.println("=== Static Polymorphism ===");
        System.out.println("Compile time decides which method!\n");

        // Java arguments dekh ke sahi method COMPILE TIME pe choose!
        System.out.println("Result: " + calculate(5, 3));
        System.out.println("Result: " + calculate(5, 3, 2));
        System.out.println("Result: " + calculate(5.5, 3.3));
        System.out.println("Result: " + calculate("Ha", 3));
        System.out.println("Result: " + calculate(1, "One"));
        System.out.println("Result: " + calculate(3.14, 2));

        System.out.println("\n=== RULE ===");
        System.out.println("Signature = name + params (NOT return type)");
        System.out.println("Compile time → method LOCKED (Early Binding)");
    }
}

public class MethodOverloading2 {

    // Type Promotion in Overloading - IMPORTANT!
    // Java smaller type ko larger mein promote karta hai

    static void show(int n) {
        System.out.println("show(int): " + n);
    }

    static void show(long n) {
        System.out.println("show(long): " + n);
    }

    static void show(double n) {
        System.out.println("show(double): " + n);
    }

    static void show(String s) {
        System.out.println("show(String): " + s);
    }

    // Promotion chain:
    // byte → short → int → long → float → double
    // char → int → long → float → double

    static void demo(int a, double b) {
        System.out.println("demo(int, double): " + a + ", " + b);
    }

    static void demo(double a, int b) {
        System.out.println("demo(double, int): " + a + ", " + b);
    }

    public static void main(String[] args) {

        System.out.println("=== Type Promotion in Overloading ===\n");

        // Exact match
        show(10);          // int    → show(int) exact!
        show(10L);         // long   → show(long) exact!
        show(10.5);        // double → show(double) exact!
        show("Hello");     // String → show(String) exact!

        System.out.println("\n--- Promotion ---");
        byte b = 5;
        show(b);           // byte → promoted to int!

        short s = 100;
        show(s);           // short → promoted to int!

        float f = 3.14f;
        show(f);           // float → promoted to double!

        char c = 'A';
        show(c);           // char → promoted to int! (65)

        System.out.println("\n--- Ambiguity demo ---");
        demo(5, 3.0);      // exact: demo(int, double)
        demo(5.0, 3);      // exact: demo(double, int)

        // demo(5, 3);     // ← AMBIGUOUS ERROR!
        //                    Both match after promotion!
        System.out.println("demo(5,3) would be AMBIGUOUS!");
    }
}

public class ConstructorOverloading1 {

    // Constructor Overloading = Static Polymorphism!
    static class Student {
        String name;
        int    age;
        String course;
        double gpa;
        String email;

        // Constructor 1: Minimal
        Student(String name) {
            this(name, 18);  // chain!
            System.out.println("C1: name only");
        }

        // Constructor 2: Name + Age
        Student(String name, int age) {
            this(name, age, "General");
            System.out.println("C2: name + age");
        }

        // Constructor 3: Name + Age + Course
        Student(String name, int age, String course) {
            this(name, age, course, 0.0);
            System.out.println("C3: +course");
        }

        // Constructor 4: With GPA
        Student(String name, int age,
                String course, double gpa) {
            this(name, age, course, gpa, "NA");
            System.out.println("C4: +gpa");
        }

        // Constructor 5: MASTER - all fields
        Student(String name, int age, String course,
                double gpa, String email) {
            this.name   = name;
            this.age    = age;
            this.course = course;
            this.gpa    = gpa;
            this.email  = email;
            System.out.println("C5: MASTER constructor");
        }

        void display() {
            System.out.println(name + " | " + age
                + " | " + course + " | " + gpa
                + " | " + email);
        }
    }

    public static void main(String[] args) {

        System.out.println("=== Constructor Overloading ===\n");

        System.out.println("--- Student with name only ---");
        Student s1 = new Student("Rahul");
        s1.display();

        System.out.println("\n--- Student with full details ---");
        Student s2 = new Student("Priya", 20,
            "CS", 3.9, "priya@mail.com");
        s2.display();

        System.out.println("\n--- Student with course ---");
        Student s3 = new Student("Amit", 19, "IT");
        s3.display();
    }
}

public class OperatorOverloading1 {

    public static void main(String[] args) {

        System.out.println("=== + Operator Overloading ===\n");

        // Case 1: Dono numbers → ADDITION
        int a = 10, b = 20;
        System.out.println("int + int = " + (a + b));   // 30

        double x = 5.5, y = 3.3;
        System.out.println("double + double = " + (x + y)); // 8.8

        // Case 2: Koi ek String → CONCATENATION
        String s = "Hello";
        System.out.println("String + int = " + (s + a));    // Hello10
        System.out.println("int + String = " + (a + s));    // 10Hello

        // Case 3: Left to right evaluation
        System.out.println("\n--- Left to right ---");
        System.out.println(10 + 20 + " Result");   // "30 Result"
        System.out.println("Result " + 10 + 20);   // "Result 1020"
        System.out.println("Result " + (10 + 20)); // "Result 30"

        // Why difference?
        // 10 + 20 + " Result"
        //   → (10+20) = 30  → 30 + " Result" = "30 Result"
        // "Result " + 10 + 20
        //   → ("Result "+10) = "Result 10" → "Result 10"+20 = "Result 1020"

        System.out.println("\n--- char + char ---");
        char c1 = 'A', c2 = 'B';
        System.out.println(c1 + c2);         // 65+66=131 (int!)
        System.out.println("" + c1 + c2);    // "AB" (String!)

        System.out.println("\n=== Java does NOT support ===");
        System.out.println("No -, *, /, ** overloading");
        System.out.println("No user-defined operator overloading");
        System.out.println("C++ supports it, Java DOES NOT!");
    }
}

public class MethodOverriding1 {

    // DYNAMIC POLYMORPHISM - Runtime decides!
    static class Animal {
        String name;

        Animal(String name) {
            this.name = name;
        }

        void sound() {
            System.out.println(name + ": Generic animal sound");
        }

        void move() {
            System.out.println(name + ": Moving somehow");
        }

        void eat() {
            System.out.println(name + ": Eating food");
        }
    }

    static class Dog extends Animal {
        Dog(String name) { super(name); }

        // OVERRIDING - same signature!
        @Override
        void sound() {
            System.out.println(name + ": Woof Woof!");
        }

        @Override
        void move() {
            System.out.println(name + ": Running on 4 legs");
        }
        // eat() NOT overridden → parent version used
    }

    static class Cat extends Animal {
        Cat(String name) { super(name); }

        @Override
        void sound() {
            System.out.println(name + ": Meow Meow!");
        }

        @Override
        void move() {
            System.out.println(name + ": Sneaking silently");
        }
    }

    static class Bird extends Animal {
        Bird(String name) { super(name); }

        @Override
        void sound() {
            System.out.println(name + ": Tweet Tweet!");
        }

        @Override
        void move() {
            System.out.println(name + ": Flying in sky");
        }
    }

    public static void main(String[] args) {

        System.out.println("=== DYNAMIC POLYMORPHISM ===");
        System.out.println("Runtime decides which method runs!\n");

        // ALL stored as Animal reference (upcasting)
        Animal[] animals = {
            new Dog("Tommy"),
            new Cat("Whiskers"),
            new Bird("Tweety"),
            new Dog("Bruno"),
            new Cat("Luna")
        };

        System.out.println("--- sound() - same call, different output ---");
        for (Animal a : animals) {
            a.sound(); // RUNTIME decides! Each object's version!
        }

        System.out.println("\n--- move() ---");
        for (Animal a : animals) {
            a.move();
        }

        System.out.println("\n--- eat() [not overridden] ---");
        for (Animal a : animals) {
            a.eat(); // ALL use Animal's version
        }

        System.out.println("\n=== KEY POINT ===");
        System.out.println("a.sound() → same CODE LINE");
        System.out.println("But DIFFERENT output for each object!");
    }
}

public class MethodOverriding2 {

    static class Parent {

        // Rule 1: public → child can make public or keep public
        public void publicMethod() {
            System.out.println("Parent: publicMethod");
        }

        // Rule 2: protected → child can make protected or public
        protected void protectedMethod() {
            System.out.println("Parent: protectedMethod");
        }

        // Rule 4: final → CANNOT override!
        final void finalMethod() {
            System.out.println("Parent: finalMethod (FINAL)");
        }

        // Rule 5: static → NOT overriding (HIDING!)
        static void staticMethod() {
            System.out.println("Parent: staticMethod");
        }

        // private → NOT visible to child, cannot override
        private void privateMethod() {
            System.out.println("Parent: privateMethod");
        }

        int getValue() { return 100; }
    }

    static class Child extends Parent {

        // ✅ Rule 1: public stays public - OK
        public void publicMethod() {
            System.out.println("Child: publicMethod (overridden)");
        }

        // ✅ Rule 2: protected → public is MORE visible - OK
        public void protectedMethod() {
            System.out.println("Child: protectedMethod (more visible)");
        }

        // ❌ Rule 3 violation (commented - would cause error):
        // protected void mustBePublic() { } ← ERROR! Less visible!

        // ❌ finalMethod() cannot override (commented):
        // void finalMethod() { } ← COMPILE ERROR!

        // static → This is METHOD HIDING, NOT overriding!
        static void staticMethod() {
            System.out.println("Child: staticMethod (HIDING)");
        }

        // private → New method in child, not override!
        private void privateMethod() {
            System.out.println("Child: privateMethod (NEW, not override)");
        }

        // ✅ Same return type - OK
        int getValue() { return 200; }
    }

    public static void main(String[] args) {

        System.out.println("=== Overriding Rules Demo ===\n");

        Child child   = new Child();
        Parent parent = child; // upcast

        System.out.println("--- Instance methods (overriding) ---");
        parent.publicMethod();     // Child's version (overriding!)
        parent.protectedMethod();  // Child's version
        parent.finalMethod();      // ALWAYS Parent's (final!)
        System.out.println("getValue: " + parent.getValue()); // 200

        System.out.println("\n--- Static methods (hiding) ---");
        Parent.staticMethod(); // Parent's (class reference)
        Child.staticMethod();  // Child's (class reference)
        parent.staticMethod(); // Parent's! (reference type decides for static)
        child.staticMethod();  // Child's

        System.out.println("\n=== OVERRIDING vs HIDING ===");
        System.out.println("Instance method: actual OBJECT decides → overriding");
        System.out.println("Static method:   REFERENCE TYPE decides → hiding");
    }
}

public class CovariantReturn1 {

    static class Animal {
        String name;
        Animal(String name) { this.name = name; }

        // Returns Animal type
        Animal getInstance() {
            System.out.println("Animal.getInstance()");
            return new Animal("Generic Animal");
        }

        void describe() {
            System.out.println("Animal: " + name);
        }
    }

    static class Dog extends Animal {
        String breed;

        Dog(String name, String breed) {
            super(name);
            this.breed = breed;
        }

        // COVARIANT RETURN: returns Dog instead of Animal!
        // Dog IS-A Animal → covariant allowed!
        @Override
        Dog getInstance() {
            System.out.println("Dog.getInstance()");
            return new Dog("New Dog", "Labrador");
        }

        @Override
        void describe() {
            System.out.println("Dog: " + name
                + " (" + breed + ")");
        }

        void bark() {
            System.out.println(name + ": Woof!");
        }
    }

    static class GoldenRetriever extends Dog {
        GoldenRetriever(String name) {
            super(name, "Golden Retriever");
        }

        // Further covariant: returns GoldenRetriever
        @Override
        GoldenRetriever getInstance() {
            System.out.println("GoldenRetriever.getInstance()");
            return new GoldenRetriever("Buddy");
        }

        @Override
        void describe() {
            System.out.println("GoldenRetriever: " + name);
        }
    }

    public static void main(String[] args) {

        System.out.println("=== Covariant Return Type ===\n");

        Animal  a = new Animal("Generic");
        Dog     d = new Dog("Tommy", "Poodle");
        GoldenRetriever g = new GoldenRetriever("Max");

        System.out.println("--- getInstance() calls ---");
        Animal  result1 = a.getInstance();
        result1.describe();

        Dog     result2 = d.getInstance();
        result2.describe();
        result2.bark(); // ← Direct Dog method! No cast needed!

        GoldenRetriever result3 = g.getInstance();
        result3.describe();

        System.out.println("\n--- Polymorphism with covariant ---");
        Animal[] animals = { a, d, g };
        for (Animal animal : animals) {
            Animal result = animal.getInstance();
            result.describe();
        }

        System.out.println("\n=== BENEFIT ===");
        System.out.println("Without covariant: (Dog) a.getInstance() → cast needed!");
        System.out.println("With covariant:    d.getInstance() → returns Dog directly!");
    }
}

public class RuntimePolymorphism1 {

    static class Shape {
        String color;

        Shape(String color) {
            this.color = color;
        }

        double getArea() { return 0; }
        double getPerimeter() { return 0; }
        String getType() { return "Shape"; }

        void display() {
            System.out.printf(
                "%-20s color=%-8s area=%8.2f  perim=%8.2f%n",
                getType(), color, getArea(), getPerimeter());
        }
    }

    static class Circle extends Shape {
        double radius;

        Circle(String color, double radius) {
            super(color);
            this.radius = radius;
        }

        @Override
        double getArea() {
            return Math.PI * radius * radius;
        }

        @Override
        double getPerimeter() {
            return 2 * Math.PI * radius;
        }

        @Override
        String getType() { return "Circle(r=" + radius + ")"; }
    }

    static class Rectangle extends Shape {
        double l, w;

        Rectangle(String color, double l, double w) {
            super(color);
            this.l = l; this.w = w;
        }

        @Override double getArea()      { return l * w; }
        @Override double getPerimeter() { return 2 * (l + w); }
        @Override String getType() {
            return "Rect(" + l + "x" + w + ")";
        }
    }

    static class Triangle extends Shape {
        double a, b, c;

        Triangle(String color, double a, double b, double c) {
            super(color);
            this.a = a; this.b = b; this.c = c;
        }

        @Override
        double getPerimeter() { return a + b + c; }

        @Override
        double getArea() {
            double s = getPerimeter() / 2;
            return Math.sqrt(s*(s-a)*(s-b)*(s-c));
        }

        @Override
        String getType() {
            return "Triangle("+a+","+b+","+c+")";
        }
    }

    // Works with ANY Shape subclass - polymorphism!
    static void printReport(Shape[] shapes) {
        System.out.printf("%-20s %-10s %-12s %-12s%n",
            "Type", "Color", "Area", "Perimeter");
        System.out.println("-".repeat(56));

        double totalArea = 0;
        for (Shape s : shapes) {
            s.display(); // RUNTIME decides which display/getArea!
            totalArea += s.getArea();
        }

        System.out.println("-".repeat(56));
        System.out.printf("Total Area: %.2f%n", totalArea);
    }

    static Shape getLargest(Shape[] shapes) {
        Shape largest = shapes[0];
        for (Shape s : shapes) {
            if (s.getArea() > largest.getArea()) {
                largest = s;
            }
        }
        return largest;
    }

    public static void main(String[] args) {

        Shape[] shapes = {
            new Circle("Red", 5),
            new Rectangle("Blue", 10, 4),
            new Triangle("Green", 3, 4, 5),
            new Circle("Yellow", 3),
            new Rectangle("Purple", 7, 2),
            new Triangle("Orange", 5, 5, 5)
        };

        System.out.println("=== Runtime Polymorphism ===\n");
        printReport(shapes);

        System.out.println("\nLargest shape: "
            + getLargest(shapes).getType());
    }
}

public class PolymorphismComplete1 {

    // BOTH types of polymorphism in ONE program!

    static class Calculator {
        String brand;

        Calculator(String brand) {
            this.brand = brand;
            System.out.println(brand + " calculator created");
        }

        // ===== STATIC POLYMORPHISM (Overloading) =====
        double calculate(double a, double b) {
            System.out.print("[BASIC] ");
            return a + b;
        }

        double calculate(double a, double b, char op) {
            System.out.print("[BASIC-OP] ");
            switch(op) {
                case '+': return a + b;
                case '-': return a - b;
                case '*': return a * b;
                case '/': return b != 0 ? a/b : 0;
                default:  return 0;
            }
        }

        double calculate(int[] nums) {
            System.out.print("[BASIC-ARR] ");
            int sum = 0;
            for (int n : nums) sum += n;
            return sum;
        }

        // ===== DYNAMIC POLYMORPHISM base =====
        String getType() { return "Basic"; }

        void showInfo() {
            System.out.println("[" + getType() + "] " + brand);
        }
    }

    static class ScientificCalculator
            extends Calculator {

        ScientificCalculator(String brand) {
            super(brand);
        }

        // STATIC POLYMORPHISM: More overloads
        double calculate(double base, int exp) {
            System.out.print("[SCI-POW] ");
            return Math.pow(base, exp);
        }

        double calculate(double angle, String trigFunc) {
            System.out.print("[SCI-TRIG] ");
            switch(trigFunc.toLowerCase()) {
                case "sin": return Math.sin(Math.toRadians(angle));
                case "cos": return Math.cos(Math.toRadians(angle));
                case "tan": return Math.tan(Math.toRadians(angle));
                default:    return 0;
            }
        }

        // DYNAMIC POLYMORPHISM: Override
        @Override
        String getType() { return "Scientific"; }

        @Override
        double calculate(double a, double b) {
            System.out.print("[SCI-BASIC] ");
            return super.calculate(a, b);
        }
    }

    static class ProgrammerCalculator
            extends ScientificCalculator {

        ProgrammerCalculator(String brand) {
            super(brand);
        }

        // New overload
        String calculate(int n, String base) {
            System.out.print("[PROG-CONV] ");
            switch(base.toLowerCase()) {
                case "binary": return Integer.toBinaryString(n);
                case "hex":    return Integer.toHexString(n).toUpperCase();
                case "octal":  return Integer.toOctalString(n);
                default:       return String.valueOf(n);
            }
        }

        @Override
        String getType() { return "Programmer"; }
    }

    public static void main(String[] args) {

        System.out.println("=== BOTH Polymorphism Types ===\n");

        // ===== STATIC POLYMORPHISM =====
        System.out.println("--- Static Polymorphism (Overloading) ---");
        ScientificCalculator sci = new ScientificCalculator("Casio");

        System.out.printf("5+3    = %.0f%n", sci.calculate(5, 3));
        System.out.printf("5*3    = %.0f%n", sci.calculate(5, 3, '*'));
        System.out.printf("2^8    = %.0f%n", sci.calculate(2.0, 8));
        System.out.printf("sin30  = %.4f%n", sci.calculate(30, "sin"));
        System.out.printf("Array  = %.0f%n", sci.calculate(new int[]{1,2,3,4,5}));

        // ===== DYNAMIC POLYMORPHISM =====
        System.out.println("\n--- Dynamic Polymorphism (Overriding) ---");

        // All stored as Calculator (upcasting)
        Calculator[] calcs = {
            new Calculator("Basic-Brand"),
            new ScientificCalculator("Casio-Sci"),
            new ProgrammerCalculator("TI-Prog")
        };

        for (Calculator c : calcs) {
            c.showInfo();   // RUNTIME decides getType()!
        }

        ProgrammerCalculator prog = new ProgrammerCalculator("TI");
        System.out.println("\n255 in binary: " + prog.calculate(255, "binary"));
        System.out.println("255 in hex:    " + prog.calculate(255, "hex"));
        System.out.println("255 in octal:  " + prog.calculate(255, "octal"));
    }
}