Dart OOP: Mixins, Linearization, and Extensions

Dart is a pure Object-Oriented language where every value—including numbers, functions, and null—is an object. Beyond traditional class-based inheritance, Dart provides sophisticated mechanisms like Mixins and Extensions to facilitate modular code reuse and architectural flexibility.

1. Optimized Constructor Patterns

Dart’s constructor syntax is specifically designed to minimize the boilerplate typical of complex UI frameworks like Flutter.

• Initializer Lists: Fields can be assigned directly in the constructor signature using the this.field shorthand. For more complex logic, the colon-prefixed list allows initialization before the constructor body executes.
• Named Constructors: To improve readability, Dart supports multiple constructors per class with descriptive names (e.g., Color.fromRGB(...) vs. Color.fromHex(...)).
• Factory Constructors: Using the factory keyword allows a constructor to return an existing instance from a cache or an instance of a specific subclass, rather than being forced to create a new object of its own type.

2. Unified Interface System

Unlike Java or C#, Dart does not have an interface keyword. Instead, every class implicitly defines an interface.

• extends (Inheritance): Facilitates single inheritance. A subclass inherits both the implementation (logic) and state (fields) of its parent.
• implements (Interface implementation): Allows a class to support multiple interfaces. When implementing another class, you inherit none of its implementation; you are legally required to provide your own logic for every member and method defined in that class.

3. Mixins: Multidimensional Code Reuse

Mixins allow you to "mix in" common functionality from multiple sources without creating a deep or rigid inheritance hierarchy. You can imagine a Mixin as a standalone "feature module" that can be plugged into any class.

Mixin Linearization (MRO)

When multiple Mixins define a method with the same name, Dart resolves the conflict using a Linearization algorithm. It searches from right to left (the last Mixin added in the with clause has the highest priority).

Example: class MyApp with Network, Logging → Android will check MyApp, then Logging, then Network, and finally the base Object.

The on Constraint

You can restrict a Mixin to specific host types using the on keyword. For example, mixin MyMixin on State ensures the Mixin has access to setState() and context, but it can only be applied to classes that inherit from the Flutter State class.

4. Extensions: Non-Invasive Augmentation

Extensions allow you to add new methods, getters, or operators to existing classes (even those from third-party libraries or the SDK) without modifying their source code or using inheritance.

extension ListUtils<T> on List<T> {
  T? get secondOrNull => length > 1 ? this[1] : null;
}
// Usage: [1, 2].secondOrNull -> 2

5. Sealed Classes: Exhaustive Hierarchy

Introduced in Dart 3.0, sealed classes allow you to define a fixed set of subtypes. Because the compiler knows exactly which subclasses exist (they must be in the same file), it can perform Exhaustive Matching:

double calculateArea(Shape shape) => switch (shape) {
  Circle(radius: var r) => 3.14 * r * r,
  Square(side: var s) => s * s,
  // No 'default' needed; the compiler knows these are the only two shapes!
};

This pattern provides extreme safety when modeling complex application states (e.g., Loading, Success, Error).