Classes and constructors

Why classes?

Apps deal with things: products, orders, users. A class describes one kind of thing: what data it has (fields) and what it can do (methods). An object (instance) is one actual thing created from the class. Every Flutter widget is a class too, so understanding classes is essential.

class Product {
  final String name;
  final int pricePaise;
  int stock;

  Product(this.name, this.pricePaise, this.stock);      // this.field shorthand

  bool get inStock => stock > 0;                         // getter
  String get priceText => 'Rs ${pricePaise ~/ 100}';

  void sell(int qty) {
    if (qty > stock) throw StateError('Only $stock left');
    stock -= qty;
  }

  @override
  String toString() => 'Product($name, $priceText, stock: $stock)';
}

void main() {
  final p = Product('Steel bottle', 49900, 3);
  p.sell(2);
  print(p);                 // Product(Steel bottle, Rs 499, stock: 1)
  print(p.inStock);         // true
}

Fields marked final must be set once, in the constructor, and never change; that makes objects predictable. Plain fields (like stock above) can change. A getter such as inStock has no stored value: it is calculated every time you read it, so it can never be out of date.

Named constructors

A class can have several constructors with different names: ClassName.something(...). They are very common for creating objects from JSON or with preset values.

class Product {
  final String name;
  final int pricePaise;

  Product({required this.name, required this.pricePaise});

  Product.free(this.name) : pricePaise = 0;              // named + initializer list

  factory Product.fromJson(Map<String, dynamic> json) {
    return Product(name: json['name'] as String, pricePaise: json['price'] as int);
  }
}

const constructors

If all fields are final and the constructor is marked const, you can create compile-time constant objects with const. Identical const objects are created once and shared. Flutter widgets use this a lot: const Text('Hello') and const SizedBox(height: 8) let Flutter skip rebuilding parts of the screen.

class Spacing {
  final double value;
  const Spacing(this.value);
}

void main() {
  const a = Spacing(8);
  const b = Spacing(8);
  print(identical(a, b));     // true: one shared object
}

factory constructors

A normal constructor always creates a new object of exactly that class. A factory constructor can run code first and return an existing object (a cache), or an object of a subtype. fromJson constructors are often factories because they parse and validate before creating.

Privacy with _

Dart has no public, private or protected keywords. A name that starts with an underscore (_balance, _calculate) is private to its library, which normally means its file. Code in other files cannot see it.

class Wallet {
  int _balance = 0;                // private field
  int get balance => _balance;     // read-only from outside

  void add(int amount) {
    if (amount <= 0) throw ArgumentError('amount must be positive');
    _balance += amount;
  }
}

Common mistakes

• Forgetting to initialise final fields: "must be initialized". Use this.field in the constructor or an initializer list.
• Making fields public and mutable everywhere. Prefer final fields and methods that check the rules.
• Expecting _private to mean private to the class. It is private to the file.
• Missing const on constructors of simple immutable classes, losing the performance benefit in Flutter.