D.2.2 Inheritance Notes

Inheritance

The Parent-Child Relationship

1. Parent Class (Superclass):
   1. Contains common data and actions that can be shared with multiple child classes.
   2. Serves as a blueprint for its subclasses.
2. Child Class (Subclass):
   1. Inherits data and actions from the parent class.
   2. Can add new features or override existing ones to provide specialised behaviour.

public class Dog extends Animal {
  ...
}

How Inheritance Works

1. Data inheritance:
   1. Child classes inherit attributes from the parent class.
   2. These attributes can be used or overridden as needed.
2. Action inheritance:
   1. Child classes inherit methods from the parent class.
   2. Methods can be overridden to provide specialised behaviour.

public class Bird { // parent class
    public void fly() {
        System.out.println("This bird can fly.");
    }

    public void eat() {
        System.out.println("The bird is eating.");
    }

    public void swim() {
        System.out.println("Some birds can swim.");
    }
}

public class Penguin extends Bird { // child class
    @Override
    public void fly() { // overriding the fly() method
        System.out.println("Penguins cannot fly.");
    }
    
    public static void main(String[] args) {
        Bird genericBird = new Bird();
        genericBird.fly();   // output: This bird can fly.
        genericBird.eat();   // output: The bird is eating.

        Penguin penguin = new Penguin();
        penguin.fly();       // output: Penguins cannot fly.
        penguin.eat();       // output: The bird is eating.
        penguin.swim();      // output: Some birds can swim.
    }
}

Advantages of Inheritance

Code reusability:

1. Inheritance allows child classes to reuse the data and actions of a parent class.
2. This eliminates the need to rewrite code, reducing duplication and errors.

public class Vehicle { // parent class
    public void start() {
        System.out.println("Vehicle is starting...");
    }

    public void stop() {
        System.out.println("Vehicle is stopping...");
    }
}

public class Car extends Vehicle { // child class
    public void honk() {     // car-specific feature
        System.out.println("Car horn: Beep Beep!");
    }
    
    public static void main(String[] args) {
        Car myCar = new Car();

        // testing inherited methods from Vehicle
        myCar.start();
        myCar.stop();

        // testing car-specific method
        myCar.honk();
    }
}

Extensibility:

1. Inheritance enables child classes to extend the functionality of a parent class.
2. Child classes can add new methods or override existing ones to suit their specific needs.

Reduced maintenance overheads:

1. Changes made to a parent class automatically propagate to all child classes.
2. This centralises updates, reducing the effort required to maintain the codebase.

Information hiding:

1. Parent classes can control which data and methods are accessible to child classes.
2. This ensures that sensitive or irrelevant details are kept hidden, promoting a cleaner and more secure design.

Hierarchical organisation:

1. Inheritance naturally organises code into a hierarchy, reflecting real-world relationships.
2. This structure makes it easier to understand and navigate the codebase.

Disadvantages of Inheritance

1. Tight coupling:
   1. Child classes are tightly coupled to their parent classes, making changes to the parent class potentially disruptive.
2. Single inheritance:
   1. Most programming languages, like Java, support only single inheritance, where a class can inherit from only one parent.
   2. This limitation is addressed by interfaces or mixins.

Inheritance in UML Diagrams

UML (Unified Modelling Language) diagrams visually represent inheritance relationships using an open arrow pointing from the child class to the parent class.

Example