Polymorphism (OOP) (Cambridge (CIE) A Level Computer Science): Revision Note

Polymorphism (OOP)

What is polymorphism?

• In A Level Computer Science, polymorphism is a concept in programming that allows objects to take on different forms or behaviours

• Different objects can share the same name or behaviour but can work in different ways

• It helps make code more flexible, reusable, and easier to maintain

• It allows flexibility and reusability in programming, making it easier to write and manage code

• Objects can be treated as belonging to a common group, even if they belong to different classes, making your code more versatile and adaptable to changes

Example 1 – method overloading

Method Overloading Example 1

• In the example above, all three classes all have a method named move(). Polymorphism allows methods to be declared with the same name but execute different code (in this case printing different messages)

• The override keyword Is used to provide a new implementation for a method that is already defined in the parent class (base class)

Example 2 - method overloading

Method Overloading Example 2

• In the above example both the Motorcycle class and the Car class both inherit from the base class 'Cars'

• Objects from the Motorcycle Class and the Car class can call the startEngines() method which will output "Engines Started!"

• If either of the object types call the displayInfo() method, the program will execute the method from the objects class as it overrides the Vehicle class method

• For example

  • If a motorcycle object calls the displayInfo() method, "I am a Motorcycle!" will be output

  • If a Car object calls the displayInfo() method, "I am a Car!" will be output

Treating objects as common groups

• Polymorphism also allows objects of different classes to be treated as objects of a common superclass or base class

• For example:

  • Vehicle vehicle1 = new Car()

  • Vehicle vehicle2 = new Motorcycle()

• This allows an array of type Vehicle to store both Motorcycle and Car objects rather than in separate data structures

  • If the vehicle1.displayInfo() method is called, it will still output "I am a Car!"

  • If the vehicle2.displayInfo() method is called, it will still output "I am a Motorcycle!"

• This flexibility provided by polymorphism are essential for creating more maintainable and modular code

Programming polymorphism (OOP)

How do you program polymorphism?

Run-time polymorphism

• This happens when a subclass overrides a method defined in a superclass, and the correct version is chosen at run-time, not compile-time

Example scenario: Animal, dog, and cat

Step-by-step logic (pseudocode)

1. Define a superclass called Animal with a method speak() that does nothing

2. Create subclasses called Dog and Cat that inherit from Animal

3. In each subclass, override the speak() method to provide a specific output

4. Write a function make_sound(animal) that accepts an object of type Animal and calls its speak() method

5. Create instances of Dog and Cat, and pass them to make_sound()

CLASS Animal
    METHOD speak()
        // Empty method (acts as a placeholder)

CLASS Dog EXTENDS Animal
    METHOD speak()
        OUTPUT "Woof"

CLASS Cat EXTENDS Animal
    METHOD speak()
        OUTPUT "Meow"

PROCEDURE make_sound(animal : Animal)
    CALL animal.speak()

// Create objects
DECLARE myDog : Dog
DECLARE myCat : Cat

SET myDog TO NEW Dog()
SET myCat TO NEW Cat()

// Demonstrate polymorphism
CALL make_sound(myDog)  // Outputs: Woof
CALL make_sound(myCat)  // Outputs: Meow

• Animal is a base class with a speak() method

• Dog and Cat are subclasses that override the speak() method

• make_sound() takes an Animal object but calls the correct version of speak() depending on whether it’s a Dog or a Cat

• This demonstrates run-time polymorphism – the method call is resolved based on the actual type of the object

Python

class Animal:
    def speak(self):
        pass  # Placeholder method

class Dog(Animal):
    def speak(self):
        print("Woof")

class Cat(Animal):
    def speak(self):
        print("Meow")

def make_sound(animal):
    animal.speak()

dog = Dog()
cat = Cat()

make_sound(dog)  # Outputs: Woof
make_sound(cat)  # Outputs: Meow

• This shows method overriding

• The make_sound() function relies on dynamic method binding

Java

class Animal {
    public void speak() {
        // Empty default method
    }
}

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

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

public class Main {
    public static void makeSound(Animal animal) {
        animal.speak();
    }

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

        makeSound(dog); // Outputs: Woof
        makeSound(cat); // Outputs: Meow
    }
}

• Recognise use of a superclass reference (Animal animal) pointing to a subclass object

• Polymorphism occurs when animal.speak() dynamically calls the correct overridden method