Java Inheritance

Without inheritance, you'd duplicate code across similar classes:

// ❌ WITHOUT inheritance — massive code duplication!
class Dog {
    String name;      // duplicated
    int age;          // duplicated
    void eat() { }    // duplicated
    void sleep() { }  // duplicated
    void bark() { }   // unique to Dog
}

class Cat {
    String name;      // duplicated!
    int age;          // duplicated!
    void eat() { }    // duplicated!
    void sleep() { }  // duplicated!
    void purr() { }   // unique to Cat
}

// ✅ WITH inheritance — shared code written ONCE
class Animal {
    String name;
    int age;
    void eat() { System.out.println(name + " eats"); }
    void sleep() { System.out.println(name + " sleeps"); }
}

class Dog extends Animal {
    void bark() { System.out.println(name + " barks!"); }
}

class Cat extends Animal {
    void purr() { System.out.println(name + " purrs..."); }
}

super refers to the parent class. You use it in two main places:

class Animal {
    String name;
    int age;

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

    void speak() {
        System.out.println(name + " makes a sound");
    }
}

class Dog extends Animal {
    String breed;

    // 1. super() in constructor — MUST be first line!
    Dog(String name, int age, String breed) {
        super(name, age);    // Calls Animal's constructor
        this.breed = breed;  // Then set Dog-specific field
    }

    // 2. super.method() — call parent's version
    @Override
    void speak() {
        super.speak();  // "Rex makes a sound"
        System.out.println(name + " barks! 🐕");
    }
}

A child class can override a parent's method to provide its own implementation. The method signature (name, parameters, return type) must match exactly. Always use the @Override annotation for safety.

class Animal {
    void speak() {
        System.out.println("Some generic animal sound");
    }
}

class Dog extends Animal {
    @Override  // Tells compiler: "I'm intentionally replacing parent's version"
    void speak() {
        System.out.println("Woof! 🐕");
    }
}

class Cat extends Animal {
    @Override
    void speak() {
        System.out.println("Meow! 🐱");
    }
}

// Each type speaks differently:
new Animal().speak();  // "Some generic animal sound"
new Dog().speak();     // "Woof! 🐕"
new Cat().speak();     // "Meow! 🐱"

Polymorphism is the most powerful concept in OOP. It means a parent type variable can hold any child type object, and method calls automatically use the child's version. Think of it like a universal TV remote — the "power" button does something different on every TV brand.

// The parent type can hold ANY child object
Animal myPet = new Dog("Rex", 5, "Lab");
myPet.speak();  // "Woof! 🐕" — calls Dog's version!
myPet.eat();    // "Rex is eating" — inherited from Animal

// Process different animals uniformly
Animal[] zoo = {
    new Dog("Rex", 5, "Lab"),
    new Cat("Whiskers", 3),
    new Bird("Tweety", 1)
};

for (Animal a : zoo) {
    a.speak();  // Each animal speaks differently!
}
// → "Rex barks!" / "Whiskers meows!" / "Tweety chirps!"

Sometimes you have a parent type variable but need to know the actual type at runtime. Use instanceof:

Animal pet = new Dog("Rex", 5, "Lab");

pet instanceof Dog     // true  — it IS a Dog
pet instanceof Animal  // true  — it's also an Animal
pet instanceof Cat     // false — it's NOT a Cat

// Useful for type-specific actions:
if (pet instanceof Dog) {
    Dog d = (Dog) pet;  // "Casting" — now we can call Dog methods
    d.fetch();           // This method only exists on Dog
}

// Java 16+ pattern matching (cleaner):
if (pet instanceof Dog d) {
    d.fetch();  // No separate cast needed!
}

This is one of the most important design decisions you'll make. The test is simple:

class Dog extends Animal { }
class Circle extends Shape { }

class Car {
    private Engine engine; // field
}

Not all parent members are accessible to child classes. Here's what each access modifier allows:

Use protected for fields/methods that subclasses need but outsiders shouldn't access. It's the sweet spot for inheritance.