IB Computer Science Topic B3.2.1: Applying the Concept of Inheritance in OOP to Promote Code Reusability Notes

What Inheritance Is

It promotes code reusability, cuts duplication, and sets up a hierarchical relationship between classes.

Superclass and Subclass: What Each One Holds

1. Superclass (Parent Class)
   1. Holds the attributes and methods every child shares, written once.
   2. A Vehicle superclass stores speed and capacity, and defines move().
2. Subclass (Child Class)
   1. Reaches every public and protected member of the parent without repeating a line of that code.
   2. Adds its own specialised attributes and methods on top.
   3. Car adds numberOfDoors, while Aeroplane adds fly().

Four Forms of Inheritance

1. Single Inheritance: one parent, one child.
2. Multilevel Inheritance: a child becomes the parent of another child, as in Vehicle, then Car, then ElectricCar.
3. Hierarchical Inheritance: several children share one parent, as Car and Aeroplane both share Vehicle.
4. Multiple Inheritance: Python lets a class list several parents, Java does not and uses interfaces instead.

Extending a Class in Java and Python

class Vehicle {
    protected String fuelType;   // subclasses may use this
    private int serialNumber;    // subclasses may not

    public Vehicle(String fuelType) {
        this.fuelType = fuelType;
    }

    public void move() {
        System.out.println("Vehicle is moving");
    }

    public int getSerialNumber() {
        return serialNumber;
    }
}

class Aeroplane extends Vehicle {
    private int wingspan;

    public Aeroplane(String fuelType, int wingspan) {
        super(fuelType);         // initialises the inherited part
        this.wingspan = wingspan;
    }

    public void fly() {
        System.out.println("Flying on " + fuelType);
    }
}

public class TestInheritance {
    public static void main(String[] args) {
        Aeroplane a = new Aeroplane("kerosene", 60);
        a.move();   // inherited method
        a.fly();    // subclass method
    }
}

class Vehicle:
    def __init__(self, fuel_type):
        self._fuel_type = fuel_type      # one underscore: treat as protected
        self.__serial_number = 0         # two underscores: name mangled

    def move(self):
        print("Vehicle is moving")

    def get_serial_number(self):
        return self.__serial_number

class Aeroplane(Vehicle):
    def __init__(self, fuel_type, wingspan):
        super().__init__(fuel_type)      # initialises the inherited part
        self.wingspan = wingspan

    def fly(self):
        print("Flying on", self._fuel_type)

a = Aeroplane("kerosene", 60)
a.move()   # inherited method
a.fly()    # subclass method

Access Modifiers Decide What a Subclass Can Reach

1. Public: reachable from anywhere, including every subclass.
2. Protected: reachable inside the class, inside its subclasses, and inside the same package in Java.
3. Private: reachable only inside the class that declares it, so a subclass cannot touch it directly.
4. Default (Java only): no keyword written, which gives package-level access.
5. Python has no keywords for this and uses naming instead: one leading underscore means treat as protected, two triggers name mangling that hides the attribute.

class Aeroplane extends Vehicle {
    public void report() {
        System.out.println(fuelType);            // protected: compiles
        // System.out.println(serialNumber);     // private: will not compile
        System.out.println(getSerialNumber());   // public method reaches it
    }
}

class Aeroplane(Vehicle):
    def report(self):
        print(self._fuel_type)             # one underscore: still reachable
        # print(self.__serial_number)      # AttributeError: name mangled
        print(self.get_serial_number())    # public method reaches it

What This Means When You Extend a Class

1. Private members are still inherited as part of the object in memory, but the subclass cannot name them.
   1. The subclass reads them through a public getter such as getSerialNumber().
2. Protected members are the usual fix, because they let the child reuse the parent's data while outside code stays locked out, which keeps encapsulation intact.
3. Public members are reachable in the subclass and everywhere else, so they carry no protection at all.

Reuse, Maintenance and the Limits of Inheritance

1. Reusability: shared code sits in one superclass rather than being copied into every child.
2. Maintenance: fix a bug in the superclass and every subclass gets the fix, so there is one place to change instead of ten.
3. The cost: a deep chain couples the classes tightly, so an edit high up can break a subclass three levels below.
   1. Where the relationship is has a rather than is a, build the class out of component objects instead.