Classes are fundamental to object-oriented programming in Dart. They serve as blueprints for creating objects, encapsulating data and behavior into reusable units.

Defining a Class

In Dart, you can define a class using the class keyword. Here's a simple example:


class Person {
  String name;
  int age;

  void sayHello() {
    print('Hello, my name is $name');
  }
}

This class, Person, has two properties (name and age) and a method (sayHello).

Creating Objects

To create an object from a class, use the new keyword (optional in Dart 2.0+) followed by the class name:


var person = Person();
person.name = 'Alice';
person.age = 30;
person.sayHello(); // Outputs: Hello, my name is Alice

Constructors

Constructors initialize object properties when an instance is created. Dart provides several ways to define constructors:

Default Constructor


class Person {
  String name;
  int age;

  Person(this.name, this.age);
}

var person = Person('Bob', 25);

Named Constructors

Dart allows multiple constructors through named constructors:


class Person {
  String name;
  int age;

  Person(this.name, this.age);

  Person.guest() {
    name = 'Guest';
    age = 18;
  }
}

var guest = Person.guest();

Instance Variables and Methods

Instance variables store object-specific data, while methods define object behavior. Both are accessed using dot notation:


class Car {
  String model;
  int year;

  Car(this.model, this.year);

  void displayInfo() {
    print('$model ($year)');
  }
}

var myCar = Car('Tesla Model 3', 2022);
myCar.displayInfo(); // Outputs: Tesla Model 3 (2022)

Inheritance

Dart supports single inheritance, allowing classes to inherit properties and methods from a parent class:


class Vehicle {
  void move() {
    print('Moving...');
  }
}

class Car extends Vehicle {
  void honk() {
    print('Honk!');
  }
}

var car = Car();
car.move(); // Inherited from Vehicle
car.honk(); // Defined in Car

Best Practices

Use meaningful names for classes, following PascalCase convention.
Keep classes focused on a single responsibility.
Utilize Dart Getters and Setters for controlled access to properties.
Consider using Dart Abstract Classes for defining interfaces.
Implement Dart Interfaces to define a contract for classes.

Advanced Concepts

As you progress, explore these advanced class-related concepts in Dart:

Dart Mixins for reusing code across multiple class hierarchies
Dart Static Members for class-level properties and methods
Dart Generics for creating reusable, type-safe classes

Classes form the backbone of object-oriented programming in Dart. They provide a powerful way to structure your code, promote reusability, and model real-world entities in your applications.