Inheritance,
Interfaces &
Polymorphism

// SUPERCLASS
class Animal {
    String name;
    int    age;

    Animal(String name, int age) {
        this.name = name;
        this.age  = age;
    }

    void eat()    { System.out.println(name + " is eating."); }
    void breathe(){ System.out.println(name + " is breathing."); }
}

// SUBCLASS — inherits from Animal using 'extends'
class Dog extends Animal {
    String breed;  // new attribute specific to Dog

    Dog(String name, int age, String breed) {
        super(name, age);  // call superclass constructor
        this.breed = breed;
    }

    void bark() {          // new method specific to Dog
        System.out.println(name + " says: Woof!");
    }
}

class Main {
    public static void main(String[] args) {
        Dog d = new Dog("Bruno", 3, "Labrador");
        d.eat();    // inherited from Animal → "Bruno is eating."
        d.breathe(); // inherited               → "Bruno is breathing."
        d.bark();   // own method             → "Bruno says: Woof!"
        System.out.println("Breed: " + d.breed);
        System.out.println("Age:   " + d.age);   // inherited field
    }
}

class Shape {
    String color;

    Shape(String color) {
        this.color = color;
        System.out.println("Shape constructor: color = " + color);
    }

    void draw() {
        System.out.println("Drawing a " + color + " shape");
    }
}

class Circle extends Shape {
    double radius;
    String color; // shadows Shape.color → variable hiding

    Circle(String color, double radius) {
        super(color);          // ① calls Shape(color) — MUST be first!
        this.radius = radius;
        this.color  = "Bright " + color; // subclass color
    }

    void draw() {             // overrides Shape.draw()
        super.draw();          // ② calls superclass draw() first
        System.out.println("Drawing circle of radius " + radius);
    }

    void showColors() {
        System.out.println("Subclass color : " + this.color);
        System.out.println("Superclass color: " + super.color); // ③ parent field
    }
}

class Main {
    public static void main(String[] args) {
        Circle c = new Circle("Red", 5.0);
        c.draw();
        c.showColors();
    }
}

class Vehicle {
    private   String chassisNo;  // NOT accessible in subclass directly
    protected String brand;       // accessible in subclass ✅
    protected int    speed;       // accessible in subclass ✅
    public    String type;        // accessible everywhere ✅

    protected void startEngine() {
        System.out.println(brand + " engine started.");
    }

    private String getChassis() {  // can be called by Vehicle only
        return chassisNo;
    }
}

class Car extends Vehicle {
    int doors;

    Car(String brand, int speed, int doors) {
        this.brand = brand;   // ✅ protected — accessible here
        this.speed = speed;   // ✅ protected
        this.doors = doors;
        // this.chassisNo = "..."; ← ❌ COMPILE ERROR — private
    }

    void details() {
        startEngine();        // ✅ protected method — accessible
        System.out.println("Brand: " + brand + "  Doors: " + doors);
    }
}

class Employee {
    String name;
    double basicSalary;

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

    double calculateBonus() {
        return basicSalary * 0.10; // 10% bonus for all employees
    }

    void display() {
        System.out.println("Name: " + name + "  Bonus: " + calculateBonus());
    }
}

// Manager IS-A Employee (specialisation)
class Manager extends Employee {
    int teamSize;

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

    @Override
    double calculateBonus() {         // OVERRIDES Employee.calculateBonus()
        return basicSalary * 0.20      // 20% base bonus
             + teamSize * 1000;       // extra per team member
    }
}

class Main {
    public static void main(String[] args) {
        Employee e = new Employee("Aarav", 30000);
        Manager  m = new Manager("Priya", 50000, 8);

        e.display();   // bonus = 3000   (Employee version)
        m.display();   // bonus = 18000  (Manager version — overridden)
    }
}

// ABSTRACT CLASS — cannot instantiate directly
abstract class Shape {
    String color;

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

    // ABSTRACT METHODS — no body, must be overridden
    abstract double area();
    abstract double perimeter();

    // CONCRETE METHOD — has a body, inherited as-is
    void display() {
        System.out.println("Color: " + color
            + "  Area: " + area()
            + "  Perimeter: " + perimeter());
    }
}

// Concrete subclass — MUST implement all abstract methods
class Circle extends Shape {
    double radius;

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

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

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

// Another concrete subclass
class Rectangle extends Shape {
    double length, width;

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

    @Override
    double area()      { return length * width; }

    @Override
    double perimeter() { return 2 * (length + width); }
}

class Main {
    public static void main(String[] args) {
        // Shape s = new Shape("Red"); ← ❌ COMPILE ERROR: cannot instantiate abstract
        Shape c = new Circle("Blue", 5.0);     // ✅ polymorphic reference
        Shape r = new Rectangle("Red", 4.0, 6.0); // ✅
        c.display();
        r.display();
    }
}

class Point {  // implicitly extends Object
    int x, y;

    Point(int x, int y) { this.x = x; this.y = y; }

    @Override
    public String toString() {       // overrides Object.toString()
        return "(" + x + ", " + y + ")";
    }

    @Override
    public boolean equals(Object obj) {   // overrides Object.equals()
        if (this == obj) return true;
        if (!(obj instanceof Point)) return false;
        Point other = (Point) obj;
        return this.x == other.x && this.y == other.y;
    }
}

class Main {
    public static void main(String[] args) {
        Point p1 = new Point(3, 4);
        Point p2 = new Point(3, 4);
        System.out.println(p1);            // calls toString() → (3, 4)
        System.out.println(p1.equals(p2)); // → true (value equality)
        System.out.println(p1 == p2);       // → false (reference equality)
        System.out.println(p1.getClass().getName()); // → "Point"
    }
}

abstract class Shape {
    abstract void draw();
    void describe() { System.out.println("I am a shape."); }
}

class Circle    extends Shape {
    @Override void draw() { System.out.println("Drawing CIRCLE"); }
}
class Rectangle extends Shape {
    @Override void draw() { System.out.println("Drawing RECTANGLE"); }
}
class Triangle  extends Shape {
    @Override void draw() { System.out.println("Drawing TRIANGLE"); }
}

class Main {
    public static void main(String[] args) {

        // POLYMORPHIC array — Shape ref, different object types
        Shape[] shapes = {
            new Circle(),
            new Rectangle(),
            new Triangle(),
            new Circle()
        };

        // Same call → different results based on ACTUAL object type
        // This is DYNAMIC BINDING in action!
        for (Shape s : shapes) {
            s.draw();   // resolved at runtime — which draw() to call?
        }

        // OUTPUT:
        // Drawing CIRCLE
        // Drawing RECTANGLE
        // Drawing TRIANGLE
        // Drawing CIRCLE

        // Upcasting (implicit) — always safe
        Shape ref = new Circle();   // Circle IS-A Shape ✅
        ref.draw();                   // calls Circle.draw() at runtime

        // Downcasting (explicit) — needs instanceof check
        if (ref instanceof Circle) {
            Circle c = (Circle) ref;  // safe downcast
        }
    }
}

// INTERFACE — defines a contract
interface Drawable {
    // All methods are implicitly public abstract
    void draw();
    double getArea();

    // All fields are implicitly public static final (constants)
    double PI = 3.14159;  // same as: public static final double PI = 3.14159
}

// Another interface
interface Resizable {
    void resize(double factor);
}

// CLASS implementing ONE interface
class Circle implements Drawable {
    double radius;

    Circle(double r) { this.radius = r; }

    @Override
    public void draw() {
        System.out.println("Drawing circle with radius " + radius);
    }

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

// CLASS implementing MULTIPLE interfaces (solves diamond problem!)
class Square implements Drawable, Resizable {
    double side;

    Square(double s) { this.side = s; }

    @Override
    public void draw()    { System.out.println("Drawing square, side " + side); }

    @Override
    public double getArea() { return side * side; }

    @Override
    public void resize(double factor) {
        side *= factor;
        System.out.println("Square resized to side: " + side);
    }
}

class Main {
    public static void main(String[] args) {
        Drawable[] shapes = { new Circle(5), new Square(4) };
        for (Drawable d : shapes) {
            d.draw();
            System.out.println("Area: " + d.getArea());
        }

        Square sq = new Square(3);
        sq.resize(2.0);  // from Resizable
        sq.draw();       // from Drawable
    }
}

// Interface for comparing — end user defines the logic
interface Comparable {
    int compareTo(Object other);
    // Returns: negative if this < other, 0 if equal, positive if this > other
}

// Student class — USER decides: compare by marks
class Student implements Comparable {
    String name;
    int    marks;

    Student(String n, int m) { name = n; marks = m; }

    @Override
    public int compareTo(Object other) {
        Student s = (Student) other;
        return this.marks - s.marks; // ascending by marks
    }
}

// Reusable Sorter — works for ANY Comparable class!
class Sorter {
    static void bubbleSort(Comparable[] arr) {
        int n = arr.length;
        for (int i = 0; i < n-1; i++) {
            for (int j = 0; j < n-i-1; j++) {
                if (arr[j].compareTo(arr[j+1]) > 0) {
                    Comparable tmp = arr[j];
                    arr[j] = arr[j+1]; arr[j+1] = tmp;
                }
            }
        }
    }
}

class Main {
    public static void main(String[] args) {
        Student[] students = {
            new Student("Priya", 87),
            new Student("Aarav", 92),
            new Student("Rahul", 75)
        };
        Sorter.bubbleSort(students);
        for (Student s : students)
            System.out.println(s.name + ": " + s.marks);
        // Output: Rahul: 75, Priya: 87, Aarav: 92
    }
}

// Interfaces can extend other interfaces using 'extends'
interface Printable {
    void print();
}

interface Saveable extends Printable {  // interface extends interface
    void save(String filename);
}

class Document implements Saveable {    // must implement both print() AND save()
    String content;

    Document(String c) { content = c; }

    @Override
    public void print()                     { System.out.println(content); }

    @Override
    public void save(String filename)       { System.out.println("Saving to: " + filename); }
}