Polymorphism - Low-Level Design Guide

Overview

Polymorphism means 'many forms': the same call behaves differently depending on the actual object. When code calls shape.area(), a Circle and a Rectangle each run their own implementation. The caller works with the common type and never checks which concrete type it has.

Runtime (subtype) polymorphism comes from interfaces and overriding and is the one that matters most in design: it replaces switch-on-type code, supports the Open-Closed Principle, and powers nearly every design pattern. Compile-time polymorphism includes method overloading and generics.

The 'play' button

Pressing play on a music app, a video player, or a game console all 'play', but each does something different. You do not need to know the device's internals to press play.

When to use it

Code switches on a type or enum to decide behavior.
New variants will be added over time.
Collections of different but related objects processed uniformly.

Where it shows up in interviews

Replace conditional with polymorphism

Recognize it when: switch(type) repeated in several places.

Design a payment system
Design a notification service

Uniform processing

Recognize it when: iterate over mixed items (shapes, vehicles, employees).

Design a drawing app
Design payroll for employee types

Where it is used in real software

java.util.List

Code written against List works with ArrayList, LinkedList, or immutable lists.

Plugins

IDE and browser extensions implement shared interfaces the host calls polymorphically.

Web frameworks

Express middleware and Spring filters are all called the same way but do different work.

Key terms

Subtype polymorphism: One interface, many implementations, chosen at runtime.
Dynamic dispatch: The runtime picks the method based on the actual object.
Overloading: Same name, different parameter lists (compile time).
Parametric polymorphism: Generics: List<T> works for any T.

How it works, step by step

1
Spot the type switch
if (type === 'circle') ... else if ...
2
Define the common operation
area(): number.
3
Move each branch into its type
Circle.area(), Rectangle.area().
4
Call through the common type
shapes.map(s => s.area()).
5
Add new types without editing callers
Triangle implements Shape.

Switch vs polymorphism

Computing pay for full-time, contractor, and intern

Concern	switch(employee.type)	Polymorphic pay()
Add a new type	Edit every switch	Add one class
Forgotten branch	Silent bug or default	Compile error: must implement pay()
Testing	Test giant method	Test each class

NOWConcern: Add a new type | switch(employee.type): Edit every switch | Polymorphic pay(): Add one class

Polymorphism moves the decision into the type system; the switch disappears from business code.

Implementation

1interface Employee {2  name: string;3  monthlyPay(): number;4}5 6class FullTime implements Employee {7  constructor(readonly name: string, private salary: number) {}8  monthlyPay() { return this.salary / 12; }9}10 11class Contractor implements Employee {12  constructor(readonly name: string, private hourly: number, private hours: number) {}13  monthlyPay() { return this.hourly * this.hours; }14}15 16class Intern implements Employee {17  constructor(readonly name: string, private stipend: number) {}18  monthlyPay() { return this.stipend; }19}20 21const staff: Employee[] = [new FullTime("Ana", 120_000), new Contractor("Bo", 80, 120), new Intern("Cy", 2_000)];22const payroll = staff.reduce((sum, e) => sum + e.monthlyPay(), 0); // no type checks

Complexity and performance

Dynamic dispatchO(1)

Indirect call.

Adding a type1 class

No caller changes.

Trade-offs

Adding types vs adding operations

Polymorphism makes new types easy but new operations require changing every class; the Visitor pattern flips this.

Readability

Behavior is spread across classes; an IDE is needed to find all implementations.

Variants and related techniques

Pattern matching on sealed types

Java 21 switch and TypeScript unions give exhaustive checks when operations change more than types.

Duck typing

Python and JavaScript dispatch on whatever methods an object has.

Common mistakes

instanceof checks after introducing an interface.
Fix: Move the behavior into the interface.
Overloading confused with overriding.
Fix: Overloads are chosen at compile time by static type, not the runtime object.

Interview questions

How does polymorphism support the Open-Closed Principle?

Callers depend on an interface, so new behavior is added by writing a new implementation rather than modifying existing callers.

Overloading vs overriding?

Overloading: same method name with different parameters, resolved at compile time. Overriding: a subclass replaces a parent method, resolved at runtime by the actual object.

Practice problems

Problem	Difficulty	What it trains
Replace a notification-type switch with polymorphism	Easy	Refactoring.
Design shapes with area and perimeter	Easy	Interfaces.