Polymorphism

Allows objects of different types to be treated through a common interface, with each type providing its own behavior for the same call.

The Problem

Without polymorphism, code must use type-checks and branching (if/else or switch on type) to handle different object types — logic that grows and becomes error-prone every time a new type is added.

How It Works

›The same method call produces different behavior depending on the runtime type of the object
›Achieved via method overriding (subtype polymorphism) or interfaces/protocols
›Eliminates type-checking conditionals — the right implementation is dispatched automatically
›Enables writing generic code that works with any conforming type

When to Use

✓Processing heterogeneous collections uniformly (e.g., an array of Shape)

✓Plugin or strategy systems where behavior varies by type

✓Replacing switch-on-type logic with dynamic dispatch

Real-World Examples

🍎

iOS

draw() called on any UIView subclass renders that subclass's own appearance

🤖

Android

onClick() behaves differently depending on the View subclass's listener

🌐

Web

toString() overridden per class to produce custom string representations

Code Examples

Swift

protocol Shape {
    func area() -> Double
}

struct Circle: Shape {
    let radius: Double
    func area() -> Double { .pi * radius * radius }
}

struct Rectangle: Shape {
    let width: Double
    let height: Double
    func area() -> Double { width * height }
}

let shapes: [Shape] = [Circle(radius: 2), Rectangle(width: 3, height: 4)]
for shape in shapes {
    print("Area: \(shape.area())")
}