After this lesson, you will be able to:

• Override an inherited method while keeping its expected interface.
• Call the same method on objects of different subclasses.
• Use super() when an override should extend, rather than replace, parent behavior.
• Choose between one polymorphic call and repeated type-specific conditions.

Inheritance creates a relationship between types. Polymorphism lets code work with different objects through a shared method name. A subclass overrides a method by defining a method with the same name. Calling obj.summary() uses the implementation belonging to that object.

This is the Python counterpart of overriding methods in Java or C#, but you do not have to add @Override to make it work. Keep the same expected parameters and return behavior so callers do not have to know the concrete subclass.

Use super().method() when the parent already does useful work that you want to preserve. A loop can then process different objects through the same interface, instead of checking their types and duplicating branches.

1. Override a parent method

A subclass returns a specialized label when the same method is called.

class Device:
    def status(self):
        return "unknown"

class Router(Device):
    def status(self):
        return "online"

print(Device().status())
print(Router().status())

Output:

unknown
online

2. One method call, different objects

The loop doesn't need to know the exact subclass of each item.

class Alert:
    def level(self):
        return "general"

class WarningAlert(Alert):
    def level(self):
        return "warning"

class ErrorAlert(Alert):
    def level(self):
        return "error"

alerts = [WarningAlert(), ErrorAlert(), Alert()]
for alert in alerts:
    print(alert.level())

Output:

warning
error
general

3. Extend the parent's behavior

super() reuses the base message before adding subclass information.

class Build:
    def summary(self):
        return "Build complete"

class VerifiedBuild(Build):
    def summary(self):
        return f"{super().summary()} | tests passed"

print(VerifiedBuild().summary())

Output:

Build complete | tests passed

4. Return results from a shared interface

Each class supplies a label() method, so the caller can handle them uniformly.

class Transport:
    def label(self):
        return "standard"

class ExpressTransport(Transport):
    def label(self):
        return "express"

def describe(transport):
    return f"Shipping: {transport.label()}"

print(describe(ExpressTransport()))

Output:

Shipping: express

1. Giving the child method a different name and expecting an override.
2. Replacing a parent method when the requirement was to extend its message.
3. Returning a different kind of value from one subclass than the caller expects.
4. Writing a chain of type checks when every object can provide the same method.