Classes, Objects & Immutability — Flutter Course

What you'll learn

Create robust domain types with constructors, factories, value equality, const instances, and immutable update patterns. The lesson turns the APIs into a repeatable engineering workflow instead of a collection of isolated snippets.

By the end of this lesson, you'll be able to:

Apply Classes and members in a production-shaped Flutter feature
Apply Constructors in a production-shaped Flutter feature
Apply Factories in a production-shaped Flutter feature
Apply const objects in a production-shaped Flutter feature

Core mental model

Connect each API to the decision it supports. Flutter code stays maintainable when state, ownership, lifecycle, and platform boundaries are explicit.

Concept	What it means	Decision rule
Const constructor	Creates values eligible for compile-time canonicalization	Use when every field is final and construction has no runtime work
Value equality	Objects compare by meaningful fields rather than identity	Define equality consistently with hashCode for value objects
copyWith	Creates a modified value while preserving immutability	Use explicit updates instead of mutating shared state

Professional workflow

Work in small vertical slices and keep behavior observable from the first iteration.

Define the immutable lesson-progress model boundary: user goal, inputs, visible states, ownership, and expected failures.
Build the smallest working vertical slice with typed data and explicit dependencies.
Represent loading, empty, success, and failure behavior where the feature can encounter them.
Verify logic away from the UI, then exercise the rendered behavior at its public boundary.
Inspect lifecycle, accessibility, performance, security, and platform behavior before widening the feature.
Refactor only after behavior is protected by repeatable evidence.

Protect the frame

Keep build methods predictable, move side effects to explicit owners, and measure before introducing caches, isolates, or architectural layers.

Guided Flutter lab

Build a focused immutable lesson-progress model slice

This compact example keeps the important ownership and data-flow decisions visible so the behavior is easy to extend and test.

lib/progress.dart

class LessonProgress {
  const LessonProgress({required this.lessonId, this.percent = 0});

  final String lessonId;
  final int percent;

  LessonProgress copyWith({int? percent}) => LessonProgress(
    lessonId: lessonId,
    percent: percent ?? this.percent,
  );

  @override
  bool operator ==(Object other) =>
      other is LessonProgress && other.lessonId == lessonId && other.percent == percent;

  @override
  int get hashCode => Object.hash(lessonId, percent);
}

Production practice

Contract

Define the immutable lesson-progress model inputs, outputs, owner, lifecycle, visible states, and platform assumptions before selecting APIs or packages.

Verification

Protect pure rules with unit tests and the rendered public contract with widget or integration evidence; include one unavailable or failure case.

Operations

Keep dependencies replaceable, log actionable context without user secrets, and measure user-visible behavior before optimizing.

Common failure mode

A final collection field is not automatically immutable; callers can still mutate the referenced list unless ownership is controlled or a read-only copy is exposed.

Independent workshop

Extend the guided lab into a review-ready immutable lesson-progress model feature that fits the running course portfolio app.

Your finished workshop must include:

Classes and members
Constructors
Factories
const objects
Equality and hashCode
Automated verification and a short design note

Definition of done

Demonstrate the happy path, an empty or unavailable state, and at least one failure path. Add an automated check and a short note explaining one design decision.

Recap & quick check

Key takeaways

Const constructor: Use when every field is final and construction has no runtime work
Value equality: Define equality consistently with hashCode for value objects
copyWith: Use explicit updates instead of mutating shared state

Quick check

1. Which rule best applies to Const constructor?

2. Which rule best applies to Value equality?

3. Which rule best applies to copyWith?

Next: Interfaces, Mixins & Class Modifiers