// Like a remote control that works with different devices
RemoteControl remote = new UniversalRemote();

// Can control different devices polymorphically
Device tv = new Television();
Device sound = new SoundSystem();
Device lights = new SmartLights();

remote.turnOn(tv);      // TV-specific behavior
remote.turnOn(sound);   // Sound-specific behavior
remote.turnOn(lights);  // Light-specific behavior

public class Calculator {
    // Different number of parameters
    public int add(int a, int b) {
        System.out.println("Adding two integers: " + a + " + " + b);
        return a + b;
    }
    
    public int add(int a, int b, int c) {
        System.out.println("Adding three integers");
        return a + b + c;
    }
    
    // Different parameter types
    public double add(double a, double b) {
        System.out.println("Adding two doubles: " + a + " + " + b);
        return a + b;
    }
    
    public String add(String a, String b) {
        System.out.println("Concatenating strings");
        return a + b;
    }
    
    // Variable arguments (varargs)
    public int add(int... numbers) {
        System.out.println("Adding variable number of integers");
        int sum = 0;
        for (int num : numbers) {
            sum += num;
        }
        return sum;
    }
}

public class DataProcessor {
    // Different parameter order
    public void process(String data, int priority) {
        System.out.println("Processing string with priority: " + priority);
    }
    
    public void process(int priority, String data) {
        System.out.println("Processing with priority " + priority + ": " + data);
    }
    
    // Array vs varargs
    public void process(int[] numbers) {
        System.out.println("Processing array of " + numbers.length + " numbers");
    }
    
    public void process(int... numbers) {
        System.out.println("Processing varargs of " + numbers.length + " numbers");
    }
    
    // Generic overloading
    public <T> void process(T item) {
        System.out.println("Processing generic item: " + item);
    }
    
    public <T> void process(List<T> items) {
        System.out.println("Processing list of " + items.size() + " items");
    }
}

// Usage demonstration
public class OverloadingDemo {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        
        System.out.println(calc.add(5, 3));           // int, int
        System.out.println(calc.add(5, 3, 2));        // int, int, int
        System.out.println(calc.add(5.5, 3.2));       // double, double
        System.out.println(calc.add("Hello", "World")); // String, String
        System.out.println(calc.add(1, 2, 3, 4, 5));  // varargs
        
        DataProcessor processor = new DataProcessor();
        processor.process("data", 1);           // String, int
        processor.process(2, "more data");      // int, String
        processor.process(new int[]{1, 2, 3});  // array
        processor.process(4, 5, 6);            // varargs
    }
}

// Base class
public abstract class Animal {
    protected String name;
    protected String species;
    
    public Animal(String name, String species) {
        this.name = name;
        this.species = species;
    }
    
    // Method to be overridden
    public abstract void makeSound();
    
    // Method with default implementation
    public void sleep() {
        System.out.println(name + " is sleeping");
    }
    
    // Method that uses polymorphic behavior
    public void performDailyRoutine() {
        System.out.println(name + " starts daily routine:");
        makeSound();  // Polymorphic call
        sleep();
    }
    
    public String getName() { return name; }
    public String getSpecies() { return species; }
}

// Derived classes
public class Dog extends Animal {
    private String breed;
    
    public Dog(String name, String breed) {
        super(name, "Canine");
        this.breed = breed;
    }
    
    @Override
    public void makeSound() {
        System.out.println(name + " (a " + breed + ") says: Woof! Woof!");
    }
    
    @Override
    public void sleep() {
        System.out.println(name + " curls up in a cozy spot and sleeps");
    }
    
    // Additional dog-specific method
    public void wagTail() {
        System.out.println(name + " is wagging tail happily!");
    }
}

public class Cat extends Animal {
    private boolean isIndoor;
    
    public Cat(String name, boolean isIndoor) {
        super(name, "Feline");
        this.isIndoor = isIndoor;
    }
    
    @Override
    public void makeSound() {
        System.out.println(name + " says: Meow! Purr...");
    }
    
    @Override
    public void sleep() {
        if (isIndoor) {
            System.out.println(name + " finds a sunny windowsill to nap");
        } else {
            System.out.println(name + " climbs a tree to sleep safely");
        }
    }
    
    public void hunt() {
        System.out.println(name + " is stalking prey silently");
    }
}

public class Bird extends Animal {
    private boolean canFly;
    
    public Bird(String name, boolean canFly) {
        super(name, "Avian");
        this.canFly = canFly;
    }
    
    @Override
    public void makeSound() {
        System.out.println(name + " chirps melodiously: Tweet! Tweet!");
    }
    
    @Override
    public void sleep() {
        if (canFly) {
            System.out.println(name + " perches on a high branch to sleep");
        } else {
            System.out.println(name + " nestles on the ground to sleep");
        }
    }
    
    public void fly() {
        if (canFly) {
            System.out.println(name + " soars through the sky gracefully");
        } else {
            System.out.println(name + " cannot fly but runs quickly");
        }
    }
}

public class AnimalShelter {
    public static void main(String[] args) {
        // Polymorphic array - different objects, same reference type
        Animal[] animals = {
            new Dog("Buddy", "Golden Retriever"),
            new Cat("Whiskers", true),
            new Bird("Tweety", true),
            new Dog("Max", "German Shepherd"),
            new Cat("Shadow", false)
        };
        
        System.out.println("=== Animal Shelter Daily Routine ===");
        for (Animal animal : animals) {
            animal.performDailyRoutine(); // Polymorphic method call
            System.out.println();
        }
    }
}

public class Shape {
    protected String color = "white";
    
    public void draw() {
        System.out.println("Drawing a generic shape in " + color);
    }
    
    public void calculateArea() {
        System.out.println("Area calculation not implemented");
    }
    
    public String getInfo() {
        return "Generic shape in " + color;
    }
}

public class Circle extends Shape {
    private double radius;
    
    public Circle(double radius, String color) {
        this.radius = radius;
        this.color = color;
    }
    
    @Override
    public void draw() {
        System.out.println("Drawing a circle with radius " + radius + 
                         " in " + color);
    }
    
    @Override
    public void calculateArea() {
        double area = Math.PI * radius * radius;
        System.out.println("Circle area: " + area);
    }
    
    @Override
    public String getInfo() {
        return "Circle with radius " + radius + " in " + color;
    }
}

public class Rectangle extends Shape {
    private double width, height;
    
    public Rectangle(double width, double height, String color) {
        this.width = width;
        this.height = height;
        this.color = color;
    }
    
    @Override
    public void draw() {
        System.out.println("Drawing a rectangle " + width + "x" + height + 
                         " in " + color);
    }
    
    @Override
    public void calculateArea() {
        double area = width * height;
        System.out.println("Rectangle area: " + area);
    }
    
    @Override
    public String getInfo() {
        return "Rectangle " + width + "x" + height + " in " + color;
    }
}

// Demonstration of dynamic dispatch
public class DispatchDemo {
    public static void main(String[] args) {
        // Reference type is Shape, object types are different
        Shape shape1 = new Circle(5.0, "red");
        Shape shape2 = new Rectangle(4.0, 6.0, "blue");
        Shape shape3 = new Shape(); // Base class object
        
        // Array of Shape references
        Shape[] shapes = {shape1, shape2, shape3};
        
        System.out.println("=== Dynamic Method Dispatch ===");
        for (int i = 0; i < shapes.length; i++) {
            System.out.println("\nShape " + (i + 1) + ":");
            System.out.println("Info: " + shapes[i].getInfo());
            
            // These calls are resolved at runtime based on actual object type
            shapes[i].draw();           // Polymorphic call
            shapes[i].calculateArea();  // Polymorphic call
        }
        
        // Demonstrating method resolution
        System.out.println("\n=== Method Resolution Analysis ===");
        analyzeMethodCalls(shape1); // Circle object
        analyzeMethodCalls(shape2); // Rectangle object
        analyzeMethodCalls(shape3); // Shape object
    }
    
    public static void analyzeMethodCalls(Shape shape) {
        System.out.println("\nAnalyzing: " + shape.getClass().getSimpleName());
        System.out.println("Method call resolution:");
        shape.draw();           // Calls overridden method in actual class
        shape.calculateArea();  // Calls overridden method in actual class
    }
}

// Interface definition
public interface Drawable {
    void draw();
    
    default void prepare() {
        System.out.println("Preparing to draw...");
    }
    
    default void cleanup() {
        System.out.println("Cleaning up after drawing");
    }
}

public interface Movable {
    void move(int x, int y);
    
    default void resetPosition() {
        move(0, 0);
    }
}

public interface Scalable {
    void scale(double factor);
    
    default void doubleSize() {
        scale(2.0);
    }
    
    default void halveSize() {
        scale(0.5);
    }
}

// Multiple interface implementation
public class GameObject implements Drawable, Movable, Scalable {
    private String name;
    private int x, y;
    private double size = 1.0;
    
    public GameObject(String name) {
        this.name = name;
    }
    
    @Override
    public void draw() {
        System.out.println("Drawing " + name + " at (" + x + "," + y + 
                         ") with size " + size);
    }
    
    @Override
    public void move(int x, int y) {
        this.x = x;
        this.y = y;
        System.out.println(name + " moved to (" + x + "," + y + ")");
    }
    
    @Override
    public void scale(double factor) {
        size *= factor;
        System.out.println(name + " scaled by " + factor + 
                         ", new size: " + size);
    }
    
    public String getName() { return name; }
}

public class GraphicsEngine {
    // Polymorphic collections
    private List<Drawable> drawableObjects = new ArrayList<>();
    private List<Movable> movableObjects = new ArrayList<>();
    private List<Scalable> scalableObjects = new ArrayList<>();
    
    public void addGameObject(GameObject obj) {
        // Same object can be stored in multiple polymorphic collections
        drawableObjects.add(obj);   // As Drawable
        movableObjects.add(obj);    // As Movable  
        scalableObjects.add(obj);   // As Scalable
    }
    
    // Polymorphic operations
    public void renderAll() {
        System.out.println("=== Rendering All Objects ===");
        for (Drawable drawable : drawableObjects) {
            drawable.prepare();     // Interface default method
            drawable.draw();        // Polymorphic call
            drawable.cleanup();     // Interface default method
        }
    }
    
    public void moveAll(int deltaX, int deltaY) {
        System.out.println("=== Moving All Objects ===");
        for (Movable movable : movableObjects) {
            // Get current position if possible (casting)
            if (movable instanceof GameObject) {
                GameObject obj = (GameObject) movable;
                System.out.println("Moving " + obj.getName());
            }
            movable.move(deltaX, deltaY);  // Polymorphic call
        }
    }
    
    public void scaleAll(double factor) {
        System.out.println("=== Scaling All Objects ===");
        for (Scalable scalable : scalableObjects) {
            scalable.scale(factor);  // Polymorphic call
        }
    }
    
    public void resetAllPositions() {
        System.out.println("=== Resetting Positions ===");
        for (Movable movable : movableObjects) {
            movable.resetPosition(); // Default interface method
        }
    }
}

// Usage demonstration
public class GameDemo {
    public static void main(String[] args) {
        GraphicsEngine engine = new GraphicsEngine();
        
        // Create different game objects
        GameObject player = new GameObject("Player");
        GameObject enemy = new GameObject("Enemy");
        GameObject powerUp = new GameObject("PowerUp");
        
        // Add to engine
        engine.addGameObject(player);
        engine.addGameObject(enemy);
        engine.addGameObject(powerUp);
        
        // Polymorphic operations
        engine.renderAll();
        engine.moveAll(10, 20);
        engine.scaleAll(1.5);
        engine.resetAllPositions();
    }
}

// Base class hierarchy
public abstract class Vehicle {
    protected String brand;
    protected String model;
    protected double price;
    
    public Vehicle(String brand, String model, double price) {
        this.brand = brand;
        this.model = model;
        this.price = price;
    }
    
    public abstract void start();
    public abstract void stop();
    public abstract double calculateMaintenanceCost();
    
    public void displayInfo() {
        System.out.println(brand + " " + model + " - $" + price);
    }
    
    // Getters
    public String getBrand() { return brand; }
    public String getModel() { return model; }
    public double getPrice() { return price; }
}

public class Car extends Vehicle {
    private int doors;
    private String fuelType;
    
    public Car(String brand, String model, double price, 
               int doors, String fuelType) {
        super(brand, model, price);
        this.doors = doors;
        this.fuelType = fuelType;
    }
    
    @Override
    public void start() {
        System.out.println("Car " + brand + " " + model + 
                         " engine started (" + fuelType + ")");
    }
    
    @Override
    public void stop() {
        System.out.println("Car engine stopped, parking brake engaged");
    }
    
    @Override
    public double calculateMaintenanceCost() {
        return price * 0.05; // 5% of car value annually
    }
    
    @Override
    public void displayInfo() {
        super.displayInfo();
        System.out.println("  Type: " + doors + "-door car, Fuel: " + fuelType);
    }
}

public class Motorcycle extends Vehicle {
    private int engineCC;
    private boolean hasWindshield;
    
    public Motorcycle(String brand, String model, double price, 
                     int engineCC, boolean hasWindshield) {
        super(brand, model, price);
        this.engineCC = engineCC;
        this.hasWindshield = hasWindshield;
    }
    
    @Override
    public void start() {
        System.out.println("Motorcycle " + brand + " " + model + 
                         " (" + engineCC + "cc) kick-started!");
    }
    
    @Override
    public void stop() {
        System.out.println("Motorcycle engine stopped, kickstand down");
    }
    
    @Override
    public double calculateMaintenanceCost() {
        return price * 0.08; // 8% of bike value annually
    }
    
    @Override
    public void displayInfo() {
        super.displayInfo();
        System.out.println("  Type: " + engineCC + "cc motorcycle" + 
                         (hasWindshield ? " with windshield" : ""));
    }
}

public class VehicleManager {
    private List<Vehicle> vehicles;
    
    public VehicleManager() {
        vehicles = new ArrayList<>();
    }
    
    public void addVehicle(Vehicle vehicle) {
        vehicles.add(vehicle);
        System.out.println("Added: " + vehicle.getBrand() + " " + 
                          vehicle.getModel());
    }
    
    // Polymorphic operations on collections
    public void startAllVehicles() {
        System.out.println("\n=== Starting All Vehicles ===");
        for (Vehicle vehicle : vehicles) {
            vehicle.start(); // Polymorphic call
        }
    }
    
    public void stopAllVehicles() {
        System.out.println("\n=== Stopping All Vehicles ===");
        for (Vehicle vehicle : vehicles) {
            vehicle.stop(); // Polymorphic call
        }
    }
    
    public void displayInventory() {
        System.out.println("\n=== Vehicle Inventory ===");
        for (Vehicle vehicle : vehicles) {
            vehicle.displayInfo(); // Polymorphic call
        }
    }
    
    public double calculateTotalMaintenanceCost() {
        double total = 0;
        for (Vehicle vehicle : vehicles) {
            total += vehicle.calculateMaintenanceCost(); // Polymorphic call
        }
        return total;
    }
    
    // Type-specific operations using instanceof
    public void performCarSpecificMaintenance() {
        System.out.println("\n=== Car-Specific Maintenance ===");
        for (Vehicle vehicle : vehicles) {
            if (vehicle instanceof Car) {
                Car car = (Car) vehicle;
                System.out.println("Performing car maintenance on: " + 
                                 car.getBrand() + " " + car.getModel());
                // Car-specific maintenance logic
            }
        }
    }
    
    // Filtering with polymorphism
    public List<Vehicle> getVehiclesByBrand(String brand) {
        List<Vehicle> result = new ArrayList<>();
        for (Vehicle vehicle : vehicles) {
            if (vehicle.getBrand().equalsIgnoreCase(brand)) {
                result.add(vehicle);
            }
        }
        return result;
    }
    
    public List<Vehicle> getVehiclesAbovePrice(double minPrice) {
        return vehicles.stream()
                      .filter(v -> v.getPrice() > minPrice)
                      .collect(Collectors.toList());
    }
}

// Usage demonstration
public class VehicleManagerDemo {
    public static void main(String[] args) {
        VehicleManager manager = new VehicleManager();
        
        // Adding different types of vehicles
        manager.addVehicle(new Car("Toyota", "Camry", 25000, 4, "Gasoline"));
        manager.addVehicle(new Car("Tesla", "Model 3", 40000, 4, "Electric"));
        manager.addVehicle(new Motorcycle("Harley", "Sportster", 15000, 883, true));
        manager.addVehicle(new Motorcycle("Honda", "CBR", 12000, 600, false));
        
        // Polymorphic operations
        manager.displayInventory();
        manager.startAllVehicles();
        manager.stopAllVehicles();
        
        System.out.println("\nTotal maintenance cost: $" + 
                          manager.calculateTotalMaintenanceCost());
        
        manager.performCarSpecificMaintenance();
    }
}

// Base graphics interface
public interface Graphic {
    void draw();
    void move(int dx, int dy);
    void resize(double factor);
    
    default void display() {
        System.out.println("Displaying: " + getDescription());
        draw();
    }
    
    String getDescription();
}

// Abstract base for shapes
public abstract class Shape implements Graphic {
    protected int x, y;
    protected String color;
    protected boolean filled;
    
    public Shape(int x, int y, String color, boolean filled) {
        this.x = x;
        this.y = y;
        this.color = color;
        this.filled = filled;
    }
    
    @Override
    public void move(int dx, int dy) {
        x += dx;
        y += dy;
        System.out.println(getDescription() + " moved by (" + dx + "," + dy + 
                         ") to (" + x + "," + y + ")");
    }
    
    @Override
    public String getDescription() {
        return (filled ? "Filled " : "Outlined ") + 
               color + " " + getShapeType() + " at (" + x + "," + y + ")";
    }
    
    protected abstract String getShapeType();
    public abstract double getArea();
    public abstract double getPerimeter();
}

// Concrete shape implementations
public class Circle extends Shape {
    private double radius;
    
    public Circle(int x, int y, String color, boolean filled, double radius) {
        super(x, y, color, filled);
        this.radius = radius;
    }
    
    @Override
    public void draw() {
        System.out.println("Drawing circle: center(" + x + "," + y + 
                         "), radius=" + radius + ", " + 
                         (filled ? "filled" : "outline") + ", color=" + color);
    }
    
    @Override
    public void resize(double factor) {
        radius *= factor;
        System.out.println("Circle resized by factor " + factor + 
                         ", new radius: " + radius);
    }
    
    @Override
    protected String getShapeType() { return "Circle"; }
    
    @Override
    public double getArea() { return Math.PI * radius * radius; }
    
    @Override
    public double getPerimeter() { return 2 * Math.PI * radius; }
}

public class Rectangle extends Shape {
    private double width, height;
    
    public Rectangle(int x, int y, String color, boolean filled, 
                    double width, double height) {
        super(x, y, color, filled);
        this.width = width;
        this.height = height;
    }
    
    @Override
    public void draw() {
        System.out.println("Drawing rectangle: corner(" + x + "," + y + 
                         "), size=" + width + "x" + height + ", " + 
                         (filled ? "filled" : "outline") + ", color=" + color);
    }
    
    @Override
    public void resize(double factor) {
        width *= factor;
        height *= factor;
        System.out.println("Rectangle resized by factor " + factor + 
                         ", new size: " + width + "x" + height);
    }
    
    @Override
    protected String getShapeType() { return "Rectangle"; }
    
    @Override
    public double getArea() { return width * height; }
    
    @Override
    public double getPerimeter() { return 2 * (width + height); }
}