Polymorphism: Cost and Benefit

Starter: think before typing

Before running this flexible substitution example, find the line where the main idea becomes active. Write a prediction: what must already be true for that line to work, and what should be different after it runs? The checked run ends with `Hello`; predict how the focus line helps produce that evidence.

Learning Objectives

• Call behaviour through a shared type.
• Explain dynamic dispatch in simple terms.
• Use polymorphism to remove a brittle conditional.
• Describe the cost of extra abstraction.

Learning Outcomes

• By the end of the lesson, you can call behaviour through a shared type.
• By the end of the lesson, you can explain dynamic dispatch in simple terms.
• By the end of the lesson, you can use polymorphism to remove a brittle conditional.
• By the end of the lesson, you can describe the cost of extra abstraction.

Why this idea exists

Polymorphism exists so different implementations can be used through the same kind of reference. The calling code asks for a behaviour, not a particular concrete class.

The idea grew with object-oriented programming and became central to flexible design because it lets programs replace condition-heavy logic with substitutable behaviours.

This lesson fits the arc after inheritance and interfaces because it asks for judgement about cost. Polymorphism can make code easier to extend and test, but too much indirection can make a small program harder to read.

Deep dive

Lesson visual

Type this and run it

Create PolymorphismCostBenefitDemo.java, type the program, and run it before changing anything. This section is about reproducing the checked baseline.

public class PolymorphismCostBenefitDemo {
  public static void main(String[] args) {
    Formatter formatter = new PlainTextFormatter();
    System.out.println(formatter.format("Hello"));
  }
}

interface Formatter {
  String format(String text);
}

class PlainTextFormatter implements Formatter {
  public String format(String text) {
    return text;
  }
}

Build and run it with:

javac PolymorphismCostBenefitDemo.java && java PolymorphismCostBenefitDemo

Expected baseline: Hello

Line-by-line explanation

Read the code as a sequence of responsibilities. The focus line for this lesson is Formatter formatter = new PlainTextFormatter();; the surrounding lines prepare it, use its result or make the behaviour observable.

Worked example

Trace the program

Common misconception

A common mistake in polymorphism: cost and benefit is treating the example as a finished answer. For flexible substitution, the important question is narrower: which operation carries the idea, what does it make possible, and what would break if you changed it carelessly?

Quick checks

How to study this lesson

For Polymorphism: Cost and Benefit, predict how flexible substitution changes the run before you press Run.

Use the first portfolio task as your main edit: Replace a conditional with two implementations of one interface.

Use the second task as your variation: Trace which implementation is selected during execution.

Finish with evidence, not a diary entry: Explain one benefit and one cost of the design.

Portfolio Practice

1. Replace a conditional with two implementations of one interface.
2. Trace which implementation is selected during execution.
3. Explain one benefit and one cost of the design.

Final self-check

Study route

Practise flexible substitution by predicting the Java example, typing it, running it in the browser, tracing the result and saving portfolio evidence.

Next, move into Collections, Generics and Iteration and carry forward one improvement from this lesson into the next program.