Polymorphism: compile-time and runtime

class Shape {
    void draw() { System.out.println("Drawing a shape"); }
}

class Circle extends Shape {
    @Override
    void draw() { System.out.println("Drawing a circle"); }
}

class Square extends Shape {
    @Override
    void draw() { System.out.println("Drawing a square"); }
}

public class Main {
    public static void main(String[] args) {
        Shape s1 = new Circle();
        Shape s2 = new Square();
        s1.draw();
        s2.draw();
    }
}

public class Main {
    static int area(int side) {
        return side * side;
    }

    static int area(int length, int width) {
        return length * width;
    }

    static double area(double radius) {
        return Math.PI * radius * radius;
    }

    public static void main(String[] args) {
        System.out.println("Square: " + area(5));
        System.out.println("Rectangle: " + area(4, 6));
        System.out.printf("Circle: %.2f%n", area(3.0));
    }
}

class Animal { }
class Dog extends Animal { }
class Cat extends Animal { }

public class Main {
    public static void main(String[] args) {
        Animal a = new Dog();
        Animal b = new Animal();
        System.out.println("a: Animal " + (a instanceof Animal) + ", Dog " + (a instanceof Dog) + ", Cat " + (a instanceof Cat));
        System.out.println("b: Animal " + (b instanceof Animal) + ", Dog " + (b instanceof Dog) + ", Cat " + (b instanceof Cat));
    }
}

public class Main {
    public static void main(String[] args) {
        Object[] values = {"Pune", 21, 3.7};
        for (Object v : values) {
            if (v instanceof String s) {
                System.out.println("String of length " + s.length());
            } else if (v instanceof Integer i) {
                System.out.println("Integer doubled: " + (i * 2));
            } else if (v instanceof Double d) {
                System.out.println("Double rounded: " + Math.round(d));
            }
        }
    }
}

class Vehicle { }

class Truck extends Vehicle {
    final int capacityKg;
    Truck(int capacityKg) { this.capacityKg = capacityKg; }
}

class Bike extends Vehicle { }

public class Main {
    public static void main(String[] args) {
        Vehicle[] fleet = { new Truck(9000), new Bike(), new Truck(6000) };
        int total = 0;
        int skipped = 0;
        for (Vehicle v : fleet) {
            if (v instanceof Truck t) {
                total += t.capacityKg;
            } else {
                skipped++;
            }
        }
        System.out.println("Truck capacity: " + total + " kg (skipped " + skipped + ")");
    }
}

public class Main {
    static void print(Object o) {
        System.out.println("print(Object): " + o);
    }

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

    public static void main(String[] args) {
        String s = "invoice";
        Object o = s;
        print(s);
        print(o);
        print((String) o);
    }
}

class Plan {
    int discount = 5;
    int getDiscount() { return discount; }
}

class GoldPlan extends Plan {
    int discount = 15;

    @Override
    int getDiscount() { return discount; }
}

public class Main {
    public static void main(String[] args) {
        Plan p = new GoldPlan();
        System.out.println("p.discount     = " + p.discount);
        System.out.println("p.getDiscount() = " + p.getDiscount());
    }
}

class Payment {
    protected final double amount;
    Payment(double amount) { this.amount = amount; }

    String process() { return "Processed Rs " + amount; }
}

class CardPayment extends Payment {
    CardPayment(double amount) { super(amount); }

    @Override
    String process() { return "Card charged Rs " + amount; }

    String sendOtp() { return "OTP sent to registered mobile"; }
}

class UpiPayment extends Payment {
    UpiPayment(double amount) { super(amount); }

    @Override
    String process() { return "UPI collect request for Rs " + amount; }
}

class CashOnDelivery extends Payment {
    CashOnDelivery(double amount) { super(amount); }

    @Override
    String process() { return "Collect Rs " + amount + " at the door"; }
}

public class Main {
    public static void main(String[] args) {
        Payment[] payments = { new CardPayment(2499), new UpiPayment(349), new CashOnDelivery(799) };
        double online = 0;
        for (Payment p : payments) {
            if (p instanceof CardPayment c) {
                System.out.println(c.sendOtp());
            }
            System.out.println(p.process());
            if (!(p instanceof CashOnDelivery)) {
                online += p.amount;
            }
        }
        System.out.println("Collected online: Rs " + online);
    }
}

class Employee {
    protected final String name;
    protected final double basic;

    Employee(String name, double basic) {
        this.name = name;
        this.basic = basic;
    }

    double monthlyPay() { return basic; }
}

class Manager extends Employee {
    private final int teamSize;

    Manager(String name, double basic, int teamSize) {
        super(name, basic);
        this.teamSize = teamSize;
    }

    @Override
    double monthlyPay() { return basic * 1.10; }

    double teamBonus() { return teamSize * 2000; }
}

public class Main {
    public static void main(String[] args) {
        Employee[] staff = {
            new Employee("Anil", 40000), new Manager("Kiran", 80000, 6), new Employee("Sara", 45000)
        };
        double total = 0;
        for (Employee e : staff) {
            double pay = e.monthlyPay();
            if (e instanceof Manager m) {
                pay += m.teamBonus();
            }
            System.out.printf("%-6s Rs %,.2f%n", e.name, pay);
            total += pay;
        }
        System.out.printf("Total  Rs %,.2f%n", total);
    }
}

class Vehicle {
    private static int counter = 0;
    protected final String id;

    Vehicle(String prefix) {
        counter++;
        id = prefix + counter;
    }

    boolean canTake(int kg, int km) { return false; }
}

class Bike extends Vehicle {
    Bike() { super("BIKE-"); }

    @Override
    boolean canTake(int kg, int km) { return kg <= 20 && km <= 15; }
}

class Van extends Vehicle {
    Van() { super("VAN-"); }

    @Override
    boolean canTake(int kg, int km) { return kg <= 500; }
}

class Drone extends Vehicle {
    Drone() { super("DRONE-"); }

    @Override
    boolean canTake(int kg, int km) { return kg <= 5 && km <= 10; }
}

public class Main {
    public static void main(String[] args) {
        Vehicle[] fleet = { new Bike(), new Van(), new Drone(), new Van() };
        int kg = 25, km = 8;
        System.out.println("Order: " + kg + " kg, " + km + " km");
        for (Vehicle v : fleet) {
            System.out.println("  " + v.id + (v.canTake(kg, km) ? "  can take it" : "  no"));
        }
    }
}