Lesson 24 of 59

5 mins read

Generics: Type Parameters, Bounds & Methods

In Plain English

Generics (`<T>`) allow you to write reusable classes, interfaces, and methods that work with any type while preserving compile-time type safety. Unlike Java (which uses type erasure), Dart's generics are **reified**, meaning type arguments are preserved at runtime (`list is List<String>` evaluates accurately). Generic type bounds (`<T extends Comparable<T>>`) restrict allowed types.

The Mental Model

"Generics are like customizable shipping crates: the crate's physical shape and handles work universally, but a label `<FragileGlass>` specifies exactly what type of cargo is safe to pack inside."

Deep Dive: How It Works

Reified Generics: Runtime type information is preserved (`<int>[] is List<int>` is `true`).

Generic Type Bounds: `class Repository<T extends Model>` ensures `T` inherits model capabilities.

Generic Methods: `T firstOrFallback<T>(List<T> items, T fallback)` provides polymorphic utility functions.

Syntax Blueprint

// Generic Stack Class
class Stack<T> {
  final List<T> _items = [];
  void push(T item) => _items.add(item);
  T pop() => _items.removeLast();
}

Generic class declaration parameterized by type T.

Core Rules to Remember

Reified at Runtime: Type information is not erased; runtime `is` checks on generic types work reliably.

Type Bounds (<T extends Base>): Constrains type parameters to specific class hierarchies.

Zero Code Duplication: Write one algorithm that works seamlessly across all data types.

Common Beginner Traps & How to Fix Them

Mistake:Using raw generic types (`List` instead of `List<String>`).

Why it happens: Legacy code habits.

How to fix: Always specify explicit type arguments to maintain Sound Null Safety and type inference.

Pro Tip: Use generic helper methods like `T clamp<T extends num>(T value, T min, T max)` for type-safe arithmetic utilities.

Live Interactive Example

Hit Run Code to see it live

Building a Generic Container Box with Bounds

Python 3.12

Output Console

Click "Run Code" to view the rendered output.

How it works: Instantiated generic Box with int and String types, and resolved findMax with type bounds.

Your Turn: Micro Challenge

No pressure! Edit the starter code below and test your solution with instant feedback.

Micro Exercise

Generic Pair Structure

Create a generic class `class Pair<A, B> { final A first; final B second; Pair(this.first, this.second); }`.
In `main()`, instantiate `final pair = Pair<String, int>("Code", 101);`.
Print `Pair: ${pair.first} -> ${pair.second}`.

Sandbox Output

Click "Run & Check" to test your solution.

Finished reading and practicing?

Mark this lesson as completed to update your course progress.