Generic Reuse

Starter: think before typing

Before running this type-safe reuse 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 `Ada scored 72`; predict how the focus line helps produce that evidence.

Learning Objectives

• Write a generic class or method.
• Explain why type parameters improve reuse.
• Recognise when generic code becomes hard to read.
• Balance reusable design against the actual task.

Learning Outcomes

• By the end of the lesson, you can write a generic class or method.
• By the end of the lesson, you can explain why type parameters improve reuse.
• By the end of the lesson, you can recognise when generic code becomes hard to read.
• By the end of the lesson, you can balance reusable design against the actual task.

Why this idea exists

Generic reuse exists because programmers often need one data shape or algorithm to work with many types without duplicating the same logic for each type.

Generics grew from the broader history of parameterised types and template-style reuse. In Java, they let collections and small utility classes preserve type information while still being reusable.

This topic fits the arc after collections and abstraction because it shows reuse with constraints. The goal is not to make everything generic, but to recognise when a type parameter removes duplication while keeping the design understandable.

Deep dive

Lesson visual

Type this and run it

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

public class GenericReuseTemplatesDemo {
  public static void main(String[] args) {
    Box<String> nameBox = new Box<>("Ada");
    Box<Integer> markBox = new Box<>(72);
    System.out.println(nameBox.value() + " scored " + markBox.value());
  }
}

record Box<T>(T value) { }

Build and run it with:

javac GenericReuseTemplatesDemo.java && java GenericReuseTemplatesDemo

Expected baseline: Ada scored 72

Line-by-line explanation

Read the code as a sequence of responsibilities. The focus line for this lesson is Box<String> nameBox = new Box<>("Ada");; the surrounding lines prepare it, use its result or make the behaviour observable.

Worked example

Trace the program

Common misconception

A common mistake in generic reuse is treating the example as a finished answer. For type-safe reuse, 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 Generic Reuse, predict how type-safe reuse changes the run before you press Run.

Use the first portfolio task as your main edit: Create a tiny generic Box record.

Use the second task as your variation: Use it with two different types.

Finish with evidence, not a diary entry: Write one warning about over-generalising code.

Portfolio Practice

1. Create a tiny generic Box record.
2. Use it with two different types.
3. Write one warning about over-generalising code.

Final self-check

Study route

Practise type-safe reuse by predicting the Java example, typing it, running it in the browser, tracing the result and saving portfolio evidence.

Next, move into Resource Lifecycle and Cleanup and carry forward one improvement from this lesson into the next program.