Module 02: Dart OOP — Classes, Mixins, and Extensions

Why OOP Matters for Flutter

Every Flutter widget is a class. Every screen, every button, every animation controller — it's all classes. If you don't understand Dart's object-oriented features, Flutter code will look like hieroglyphics.

The good news? Dart's OOP is clean and predictable. No surprises, no weird edge cases. Let's build it up piece by piece.

Class Anatomy

A class in Dart groups related data (fields) and behavior (methods) together:

class Dog {
  // Fields
  String name;
  String breed;
  int age;

  // Constructor
  Dog(this.name, this.breed, this.age);

  // Method
  String bark() => '$name says: Woof!';

  // Getter
  bool get isOld => age > 10;

  // Setter
  set nickname(String value) => name = value;

  // toString for nice printing
  @override
  String toString() => 'Dog($name, $breed, age $age)';
}

void main() {
  var rex = Dog('Rex', 'German Shepherd', 5);
  print(rex.bark());    // Rex says: Woof!
  print(rex.isOld);     // false
  print(rex);           // Dog(Rex, German Shepherd, age 5)
}

Let's break down the key pieces:

Fields and the this Shorthand

Instead of writing a verbose constructor that manually assigns each field:

// The long way
Dog(String name, String breed, int age) {
  this.name = name;
  this.breed = breed;
  this.age = age;
}

Dart lets you use the this.parameter shorthand:

// The Dart way
Dog(this.name, this.breed, this.age);

Same result, one line. You'll see this pattern in virtually every Flutter widget.

Getters and Setters

Getters (get) let you compute a value from existing fields. Setters (set) let you control how a field is assigned:

class Rectangle {
  double width;
  double height;

  Rectangle(this.width, this.height);

  // Computed property — no stored field needed
  double get area => width * height;
  double get perimeter => 2 * (width + height);

  // Setter with validation
  set dimensions(List<double> values) {
    width = values[0];
    height = values[1];
  }
}

Constructors: Three Flavors

1. Standard Constructor

class Point {
  final double x;
  final double y;

  Point(this.x, this.y);
}

var p = Point(3.0, 4.0);

2. Named Constructors

A class can have multiple constructors with different names:

class Point {
  final double x;
  final double y;

  Point(this.x, this.y);

  // Named constructor — creates a point at the origin
  Point.origin()
      : x = 0,
        y = 0;

  // Named constructor — creates from a Map
  Point.fromMap(Map<String, double> map)
      : x = map['x'] ?? 0,
        y = map['y'] ?? 0;
}

var a = Point(3.0, 4.0);
var b = Point.origin();
var c = Point.fromMap({'x': 1.0, 'y': 2.0});

3. Factory Constructors

A factory constructor can return an existing instance, a subtype, or run logic before creating the object:

class Logger {
  static final Map<String, Logger> _cache = {};
  final String name;

  // Private constructor
  Logger._internal(this.name);

  // Factory — returns cached instance if it exists
  factory Logger(String name) {
    return _cache.putIfAbsent(name, () => Logger._internal(name));
  }

  void log(String message) => print('[$name] $message');
}

void main() {
  var a = Logger('API');
  var b = Logger('API');
  print(identical(a, b));  // true — same instance!
}

Factory constructors are the Dart way to implement patterns like singletons and caching. In Flutter, you'll see them in theming and service layers.

Inheritance with extends

Inheritance lets a class inherit fields and methods from a parent class:

class Animal {
  final String name;

  Animal(this.name);

  String speak() => '$name makes a sound';
}

class Cat extends Animal {
  final bool isIndoor;

  Cat(super.name, {this.isIndoor = true});

  @override
  String speak() => '$name says: Meow!';
}

class Dog extends Animal {
  Dog(super.name);

  @override
  String speak() => '$name says: Woof!';
}

void main() {
  Animal cat = Cat('Whiskers');
  Animal dog = Dog('Rex');

  print(cat.speak());  // Whiskers says: Meow!
  print(dog.speak());  // Rex says: Woof!

  // Polymorphism in action:
  var animals = <Animal>[cat, dog];
  for (var animal in animals) {
    print(animal.speak());
  }
}

Key points: - extends creates an "is-a" relationship (a Cat is an Animal) - @override marks methods you're replacing from the parent - super.name passes the argument up to the parent constructor - A variable typed as Animal can hold a Cat or Dog (polymorphism)

Abstract Classes

Abstract classes define a contract — they declare methods that subclasses must implement, but don't provide implementations themselves:

abstract class Shape {
  // Abstract method — no body, just the signature
  double area();
  double perimeter();

  // Concrete method — has an implementation
  String describe() => 'Area: ${area()}, Perimeter: ${perimeter()}';
}

class Circle extends Shape {
  final double radius;
  Circle(this.radius);

  @override
  double area() => 3.14159 * radius * radius;

  @override
  double perimeter() => 2 * 3.14159 * radius;
}

class Square extends Shape {
  final double side;
  Square(this.side);

  @override
  double area() => side * side;

  @override
  double perimeter() => 4 * side;
}

void main() {
  // Shape s = Shape();  // ERROR! Can't instantiate abstract class
  Shape circle = Circle(5);
  print(circle.describe());  // Area: 78.53975, Perimeter: 31.4159
}

Abstract classes are blueprints. They say "any Shape must be able to calculate its area and perimeter" without dictating how.

Mixins: Multiple Inheritance, Done Right

Most languages forbid multiple inheritance because it creates ambiguity (the "diamond problem"). Dart sidesteps this with mixins — reusable bundles of behavior you can snap onto any class.

mixin Swimming {
  void swim() => print('$runtimeType is swimming');
}

mixin Flying {
  void fly() => print('$runtimeType is flying');
}

mixin Running {
  void run() => print('$runtimeType is running');
}

class Duck with Swimming, Flying, Running {
  String name;
  Duck(this.name);
}

class Penguin with Swimming, Running {
  String name;
  Penguin(this.name);
}

void main() {
  var donald = Duck('Donald');
  donald.swim();  // Duck is swimming
  donald.fly();   // Duck is flying
  donald.run();   // Duck is running

  var tux = Penguin('Tux');
  tux.swim();     // Penguin is swimming
  tux.run();      // Penguin is running
  // tux.fly();   // ERROR! Penguins can't fly — no Flying mixin
}

The with keyword attaches mixins. Each mixin adds its methods to the class.

When to Use Mixins vs. Inheritance

• Inheritance (extends): "A Cat is an Animal" — shared identity
• Mixins (with): "A Duck can swim, fly, and run" — shared capabilities

In Flutter, the most common mixin you'll encounter is TickerProviderStateMixin, which gives animation capabilities to a State class:

class _MyWidgetState extends State<MyWidget> with TickerProviderStateMixin {
  // Now this state class can provide Tickers for animations
}

Extensions: Adding Powers to Existing Types

What if you want to add a method to String or int — types you didn't write? Extensions let you do exactly that:

extension StringExtras on String {
  String get reversed => split('').reversed.join('');
  bool get isPalindrome => this == reversed;
  String truncate(int maxLength) =>
      length <= maxLength ? this : '${substring(0, maxLength)}...';
}

extension IntExtras on int {
  bool get isEven => this % 2 == 0;
  String get ordinal {
    if (this % 100 >= 11 && this % 100 <= 13) return '${this}th';
    switch (this % 10) {
      case 1: return '${this}st';
      case 2: return '${this}nd';
      case 3: return '${this}rd';
      default: return '${this}th';
    }
  }
}

void main() {
  print('racecar'.isPalindrome);   // true
  print('hello'.reversed);         // olleh
  print('Long sentence here'.truncate(10));  // Long sente...
  print(1.ordinal);   // 1st
  print(42.ordinal);  // 42nd
}

The Cascade Operator (..)

The cascade operator lets you make multiple calls on the same object without repeating its name:

class EmailBuilder {
  String to = '';
  String subject = '';
  String body = '';

  void send() => print('Sending to $to: $subject');
}

void main() {
  // Without cascades — repetitive
  var email = EmailBuilder();
  email.to = 'campbell@example.com';
  email.subject = 'Welcome!';
  email.body = 'Hello and welcome to the team.';
  email.send();

  // With cascades — clean and fluent
  EmailBuilder()
    ..to = 'campbell@example.com'
    ..subject = 'Welcome!'
    ..body = 'Hello and welcome to the team.'
    ..send();
}

The .. returns the object itself instead of the method's return value, allowing you to chain calls. You'll see this in Flutter for configuring objects that don't use named constructors.

There Are No Dumb Questions

Q: Why can't I just use top-level functions instead of classes? A: You can — and sometimes you should. But classes bundle related data and behavior together. When you have a User with a name, email, and a method to sendVerification(), a class is the natural container. Flutter requires classes for widgets because it needs the build() method pattern.

Q: What's the difference between abstract class and mixin? A: An abstract class defines a type (you can use it as a type annotation like Shape myShape). A mixin defines reusable behavior but isn't a type you'd typically use in annotations. Abstract classes can have constructors; mixins cannot. Use abstract classes for "what something is," mixins for "what something can do."

Q: When would I use a factory constructor instead of a named constructor? A: Factory constructors are for when you need logic before creating the object — caching (return an existing instance), returning a subtype, or parsing/validation. Named constructors are just alternate ways to initialize the same class. If new always creates a fresh instance, use a named constructor. If you might not, use factory.

Q: Can a mixin have state (fields)? A: Yes! Mixins can declare fields and methods. Any class that uses the mixin gets those fields. Just be aware that each class gets its own copy of the fields — they're not shared.

Sharpen Your Pencil

Exercise 1: classes.dart

Build a small class hierarchy for a music library:

1. Create a Song class with title, artist, durationInSeconds (all final), a constructor using this. shorthand, a getter durationFormatted that returns a string like "3:45", and a toString() override
2. Create a Playlist class with a name and a List<Song>, methods to addSong() and removeSong(), a getter totalDuration that sums all songs, and a toString() that lists all songs
3. Create at least 3 songs and a playlist, then print the playlist

class Song {
  final String title;
  final String artist;
  final int durationInSeconds;

  Song(this.title, this.artist, this.durationInSeconds);

  String get durationFormatted {
    var minutes = durationInSeconds ~/ 60;
    var seconds = durationInSeconds % 60;
    return '$minutes:${seconds.toString().padLeft(2, '0')}';
  }

  @override
  String toString() => '$title by $artist ($durationFormatted)';
}

Exercise 2: mixins.dart

1. Create three mixins: Serializable (with a toJson() method), Printable (with a prettyPrint() method), and Validatable (with a validate() method that returns bool)
2. Create a UserProfile class that uses all three mixins
3. Demonstrate that each mixin's methods work on a UserProfile instance

Exercise 3: extensions.dart

1. Write an extension on List<int> that adds sum, average, and max getters
2. Write an extension on DateTime that adds a timeAgo getter returning a human-readable string like "2 hours ago" or "yesterday"
3. Write an extension on String that adds a toTitleCase getter ("hello world" becomes "Hello World")
4. Test all your extensions in main()

📝 Module Quiz

Test what you learned. 45 seconds per question. Passing score is set per module. Your best attempt is saved in your browser so you can track progress -- nothing is sent to a server.

What's Next?

You now have classes, constructors, inheritance, mixins, extensions, and cascades in your toolkit. That's the OOP foundation you need for Flutter. In Module 03, we tackle asynchronous programming — Futures, async/await, and Streams. This is what lets your app fetch data from the internet, read files, and handle events without freezing the UI.