1. Core Idea: Inheritance

Inheritance lets you say: “Class B is a kind of Class A.”
Then B automatically gets A’s fields and methods, and you can add or customize behavior.

Superclass (parent): general concept (e.g., Animal, Vehicle).
Subclass (child): more specific concept (e.g., Dog, Car).

Syntax:

class Parent {
    // common data and behavior
}

class Child extends Parent {
    // extra or specialized behavior
}

Use inheritance when the relationship “is a” makes sense:

Dog is an Animal.
Car is a Vehicle.
Student is a Person.

2. Simple Inheritance Step by Step

2.1 Create the parent class

public class Animal {
    String name;

    public void eat() {
        System.out.println("I can eat food.");
    }

    public void sleep() {
        System.out.println("I can sleep.");
    }
}

Animal has common behavior: eat and sleep.
Any animal should have these abilities.

2.2 Create the child class

public class Dog extends Animal {

    public void bark() {
        System.out.println("Woof! Woof!");
    }
}

Here, Dog:

Inherits name, eat(), and sleep() from Animal.
Adds new behavior: bark().

2.3 Use it in `main`

public class InheritanceDemo {
    public static void main(String[] args) {
        Dog dog = new Dog();

        dog.name = "Rocky";   // inherited field
        dog.eat();            // inherited method
        dog.sleep();          // inherited method
        dog.bark();           // Dog-specific method

        System.out.println("Dog's name: " + dog.name);
    }
}

Output:

I can eat food.
I can sleep.
Woof! Woof!
Dog's name: Rocky

Important:

Dog did not define eat or sleep, but can use them because of inheritance.
You reuse code instead of copying methods into every animal class.

3. Method Overriding: Changing Behavior in Child

Sometimes a child class should change how a parent method behaves.

3.1 Base version in parent

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

3.2 Override in child

public class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("Bark");
    }
}

public class Cat extends Animal {
    @Override
    public void sound() {
        System.out.println("Meow");
    }
}

3.3 Test overriding

public class OverrideTest {
    public static void main(String[] args) {
        Animal generic = new Animal();
        Dog dog = new Dog();
        Cat cat = new Cat();

        generic.sound(); // Some generic animal sound
        dog.sound();     // Bark
        cat.sound();     // Meow
    }
}

Notes:

@Override tells the compiler you are intentionally overriding.
The method signature must be the same (same name + parameters).
Return type must be compatible.

4. Polymorphism: One Interface, Many Forms

Polymorphism appears when you use a parent type reference for different child objects.

4.1 Parent reference, child object

public class PolyDemo {
    public static void main(String[] args) {
        Animal a1 = new Dog(); // Animal reference, Dog object
        Animal a2 = new Cat(); // Animal reference, Cat object

        a1.sound(); // Bark  (Dog’s version)
        a2.sound(); // Meow  (Cat’s version)
    }
}

What’s happening:

At compile time, the type is Animal, so you can only call methods that exist in Animal (sound, eat, etc.).
At runtime, Java looks at the actual object type (Dog or Cat) and calls the correct sound() implementation.

This is runtime polymorphism via method overriding.

4.2 Why this is powerful

You can write code that works with Animal and automatically supports all future animals:

public class AnimalTrainer {

    public static void makeItSound(Animal animal) {
        animal.sound(); // polymorphic call
    }

    public static void main(String[] args) {
        makeItSound(new Dog());
        makeItSound(new Cat());
        // later: makeItSound(new Cow()); etc.
    }
}

You don’t change makeItSound When you add new child classes.

5. More Structured Example: Shape Hierarchy

5.1 Base class `Shape`

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

    public double area() {
        return 0.0;
    }
}

5.2 Subclasses

public class Circle extends Shape {
    private double radius;

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

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

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

public class Rectangle extends Shape {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    @Override
    public void draw() {
        System.out.println("Drawing a rectangle");
    }

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

5.3 Use polymorphic array

public class ShapeDemo {
    public static void main(String[] args) {
        Shape[] shapes = {
            new Circle(3),
            new Rectangle(4, 5),
            new Circle(1.5)
        };

        for (Shape s : shapes) {
            s.draw();                             // polymorphic
            System.out.println("Area: " + s.area());
        }
    }
}

Same method calls (draw, area) on Shape references.
Each object responds in its own way.

6. `super` Keyword and Constructor Chaining

6.1 Using `super` to call parent constructor

You often want to initialize parent fields from a child constructor.

Parent:

public class Person {
    protected String name;

    public Person(String name) {
        this.name = name;
    }
}

Child:

public class Employee extends Person {
    private double salary;

    public Employee(String name, double salary) {
        super(name);      // calls Person(name)
        this.salary = salary;
    }

    public void showInfo() {
        System.out.println("Name: " + name + ", Salary: " + salary);
    }
}

Usage:

public class SuperDemo {
    public static void main(String[] args) {
        Employee e = new Employee("Ali", 3000.0);
        e.showInfo();
    }
}

super(name) must be the first line in the constructor.
If the parent has no no‑arg constructor, you must call super(...) explicitly.

6.2 Using `super` to access parent methods

If a child overrides a method but still wants to use the parent version:

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

public class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("Dog sound:");
        super.sound(); // call parent version
    }
}

7. Access Modifiers and Inheritance

Short summary:

public – everywhere.
private – only inside the same class; not accessible in child directly.
protected – same package + subclasses.
(default) – same package only.

Example with protected:

public class Animal {
    protected String name;

    protected void displayName() {
        System.out.println("Name: " + name);
    }
}

public class Dog extends Animal {
    public void show() {
        name = "Rocky";     // allowed, because 'name' is protected
        displayName();      // allowed
    }
}

If name were private, Dog could not access it directly; you’d need getters/setters.

8. When Not to Use Inheritance

Avoid inheritance when:

The relationship is not truly “is a” (e.g., Car extends Person is nonsense).
You only want to reuse a few methods; consider a separate helper class instead.
It makes the hierarchy too complex and hard to understand.

Prefer composition (having objects as fields) when you want “has a” relationships (e.g., Car has an Engine), not inheritance.

9. Lesson 9 Practice Tasks (Detailed)

Animal Inheritance + Override
- Create Animal with:
  - protected String name;
  - public void eat() printing "Animal is eating"
  - public void sound() printing "Some sound".
- Create Dog extends Animal overriding sound() to print "Bark" and adding bark() method.
- In Main, create a Dog, set name, call eat(), sound(), and bark().
Person → Student, Employee
- Person with protected String name; protected int age; and constructor Person(String name, int age).
- Method void introduce() printing "Name: X, Age: Y".
- Student extends Person with extra field String major and constructor calling super(name, age).
- Override introduce() in Student to also print "Major: <major>".
- Employee extends Person with double salary, override introduce() to print name, age, salary.
- In Main, store a Student and an Employee in a Person[] and loop calling introduce() to see polymorphism.
Shape Area Calculator
- Use the Shape, Circle, Rectangle example or write your own.
- Add method String getType() in each class returning "Shape", "Circle", "Rectangle".
- In Main, create an array of Shape, fill with different circles and rectangles.
- Loop and print getType() and area() for each.
Vehicle Hierarchy with super
- Vehicle with protected String brand; protected int year; and constructor Vehicle(String brand, int year).
- Method void showInfo() printing both.
- Car extends Vehicle with extra field int seatCount and constructor using super.
- Override showInfo() in Car to also print seatCount but reuse parent’s print using super.showInfo().
- Test in Main.
Polymorphic Method Parameter
- Create base class Payment (method void pay()).
- Subclasses: CardPayment, CashPayment, each overriding pay() with different messages.
- Write method static void processPayment(Payment p) that prints "Processing..." then calls p.pay().
- In Main, call processPayment(new CardPayment()) and processPayment(new CashPayment()).
Polymorphic List (Bonus)
- If you’re comfortable with ArrayList, create ArrayList<Animal> and add Dog, Cat, maybe another animal.
- Loop through the list and call sound() on each, observing polymorphic behavior.

All Courses