Classes et objets Dart

Une classe est un concept fondamental de la programmation orientée objet ; elle est une description abstraite des choses du monde réel.

Les objets sont des instances concrètes de classes. Ce chapitre présente les définitions de classe, les constructeurs, les variables et méthodes membres, les getters/setters et les membres statiques en Dart.


Définition et instanciation de classe

Une classe est un modèle pour créer des objets, définissant les propriétés (données) et les comportements (méthodes) que les objets possèdent.

Exemple

// Définir une classe User
class User {
  // Variables membres (propriétés)
  String name = '';
  int age = 0;

  // Méthodes membres (comportements)
  void introduce() {
    print('Bonjour, je suis $name, j'ai $age ans.');
  }

  bool isAdult() {
    return age >= 18;
  }
}

void main() {
  // Instancier : avec le mot-clé new (new peut être omis dans Dart 2.0+)
  var user1 = User();
  user1.name = 'exemple';
  user1.age = 10;

  // Accéder aux variables membres et méthodes
  print('Nom de l'utilisateur : ${user1.name}');
  user1.introduce();
  print('Est adulte : ${user1.isAdult()}');

  // Créer un autre objet, indépendant de l'autre
  var user2 = User();
  user2.name = 'Xiao Ming';
  user2.age = 20;
  user2.introduce();
}
用户名: example
你好,我是 example,今年 10 岁。
是否成年: false
你好,我是 小明,今年 20 岁。

Depuis Dart 2.0, le mot-clé `new` est facultatif lors de l'instanciation. La convention de la communauté est d'omettre `new` pour garder le code concis. Les exemples suivants de ce tutoriel omettront `new`.


Constructeur

Un constructeur est une méthode spéciale automatiquement appelée lorsqu'un objet est créé, utilisée pour initialiser l'état de l'objet.

Dart propose plusieurs formes de constructeurs, ce qui les rend très flexibles.

Constructeur par défaut

Si vous ne définissez pas de constructeur, Dart fournit automatiquement un constructeur par défaut sans argument.

Constructeur standard

Exemple

class Student {
  String name;
  int age;

  // Constructeur normal : même nom que la classe
  Student(String name, int age) {
    this.name = name;
    this.age = age;
  }

  void printInfo() {
    print('Étudiant : $name, Âge : $age');
  }
}

void main() {
  var s1 = Student('exemple', 10);
  var s2 = Student('Xiao Ming', 15);
  s1.printInfo();
  s2.printInfo();
}
学生: example, 年龄: 10
学生: 小明, 年龄: 15

Constructeur avec sucre syntaxique

Lorsque les paramètres du constructeur sont directement assignés aux variables membres, Dart fournit une syntaxe abrégée.

Exemple

class Student {
  String name;
  int age;

  // Sucre syntaxique : this.parameterName affecte automatiquement le paramètre à une variable membre du même nom
  // Cette façon est plus concise que d'écrire manuellement this.name = name
  Student(this.name, this.age);

  void printInfo() {
    print('EXEMPLE Étudiant : $name, Âge : $age');
  }
}

void main() {
  var s = Student('exemple', 10);
  s.printInfo();
}
EXAMPLE 学生: example, 年龄: 10

Constructeur nommé

Une classe peut avoir plusieurs constructeurs nommés pour différentes logiques d'initialisation.

Exemple

class Point {
  double x;
  double y;

  // Constructeur par défaut
  Point(this.x, this.y);

  // Constructeur nommé : crée l'origine
  Point.origin()
      : x = 0,
        y = 0;

  // Constructeur nommé : crée à partir d'une valeur unique (x et y sont identiques)
  Point.diagonal(double value)
      : x = value,
        y = value;

  @override
  String toString() => 'Point($x, $y)';
}

void main() {
  var p1 = Point(3, 4);
  var p2 = Point.origin();
  var p3 = Point.diagonal(5);

  print('EXEMPLE Coordonnées : $p1, $p2, $p3');
}
EXAMPLE 坐标: Point(3.0, 4.0), Point(0.0, 0.0), Point(5.0, 5.0)

liste d'initialisation

La liste d'initialisation s'exécute avant le corps du constructeur et est utilisée pour initialiser les champs finaux ou effectuer la validation des paramètres.

Exemple

class Person {
  final String name;    // les champs finaux doivent être initialisés dans le constructeur
  final int birthYear;
  final int age;

  // Liste d'initialisation : après les deux-points, avant le corps de la fonction
  // La liste d'initialisation s'exécute avant le corps du constructeur
  Person(this.name, this.birthYear)
      : age = 2026 - birthYear,          // Propriété calculée
        assert(birthYear > 1900, 'Année de naissance invalide');  // Vérification d'assertion

  void printInfo() {
    print('EXEMPLE Utilisateur : $name, Naissance : $birthYear, Âge : $age');
  }
}

void main() {
  var p = Person('exemple', 2016);
  p.printInfo();

  // La ligne suivante déclenchera un échec d'assertion (en mode développement)
  // var p2 = Person('error', 1800);
}
EXAMPLE 用户: example, 出生: 2016, 年龄: 10

`assert` ne fonctionne qu'en mode débogage et est ignoré en mode release. Il est utilisé pour détecter les erreurs logiques tôt pendant le développement.


Variables et méthodes membres

Les variables membres stockent l'état d'un objet, et les méthodes membres définissent le comportement d'un objet.

Exemple

class BankAccount {
  // Membre privé : commence par un tiret bas, accessible uniquement dans ce fichier
  String _accountNumber;
  double _balance = 0;

  // Membre public
  String ownerName;

  BankAccount(this.ownerName, this._accountNumber);

  // Méthode publique
  void deposit(double amount) {
    if (amount > 0) {
      _balance += amount;
      print('Dépôt de ¥$amount, solde actuel : ¥$_balance');
    }
  }

  bool withdraw(double amount) {
    if (amount > 0 && amount <= _balance) {
      _balance -= amount;
      print('Retrait de ¥$amount, solde actuel : ¥$_balance');
      return true;
    }
    print('Solde insuffisant, échec du retrait');
    return false;
  }

  // Méthode privée : pour usage interne à la classe uniquement
  void _logTransaction(String type, double amount) {
    print('[Journal interne] $type: ¥$amount');
  }
}

void main() {
  var account = BankAccount('EXAMPLE', '6222-0000-1234');

  account.deposit(1000);
  account.withdraw(300);
  account.withdraw(800);  // Solde insuffisant

  // Le code externe ne peut pas accéder aux membres privés
  // print(account._balance); // Erreur : _balance est privée
}
存入 ¥1000,当前余额: ¥1000
取出 ¥300,当前余额: ¥700
余额不足,取款失败

Accesseurs et mutateurs

Les accesseurs et mutateurs sont des méthodes spéciales pour lire et écrire des variables membres.

Ils vous permettent d'exécuter une logique supplémentaire lors de l'accès aux propriétés tout en conservant la syntaxe concise d'accès aux propriétés.

Exemple

class Circle {
  double _radius;  // Variable privée stockant le rayon

  Circle(this._radius);

  // Getter : renvoie le diamètre (propriété calculée)
  double get diameter => _radius * 2;

  // Getter : renvoie l'aire
  double get area => 3.14159 * _radius * _radius;

  // Getter et Setter fonctionnent ensemble : exposer la propriété radius à l'extérieur
  double get radius => _radius;

  set radius(double value) {
    // Une logique de validation peut être ajoutée dans le Setter
    if (value <= 0) {
      throw ArgumentError('Le rayon doit être supérieur à 0');
    }
    _radius = value;
  }

  // Getter en lecture seule : aucun Setter correspondant
  String get info => 'Cercle(rayon: $_radius)';
}

void main() {
  var circle = Circle(5);

  // Utilisation du Getter (comme l'accès à une propriété normale)
  print('EXEMPLE Cercle : ${circle.info}');
  print('Diamètre : ${circle.diameter}');
  print('Aire : ${circle.area.toStringAsFixed(2)}');

  // Utilisation du Setter
  circle.radius = 10;
  print('Diamètre modifié : ${circle.diameter}');

  // Définir une valeur non valide lèvera une exception
  // circle.radius = -1; // lève ArgumentError
}
EXAMPLE 圆形: 圆(半径: 5.0)
直径: 10.0
面积: 78.54
修改后直径: 20.0

L'avantage des accesseurs et mutateurs est que l'appelant n'a pas besoin de savoir si `radius` est un simple champ ou une propriété calculée. Si une logique de validation doit être ajoutée à `radius` à l'avenir, vous pouvez simplement changer le champ en accesseur/mutateur, et le code appelant n'a pas besoin d'être modifié. C'est l'avantage de l'encapsulation.


Membres statiques

Les membres statiques appartiennent à la classe elle-même, et non à une instance de la classe.

Toutes les instances partagent la même variable statique, et les méthodes statiques peuvent être appelées sans créer d'objet.

Exemple

class Counter {
  // Variable statique : partagée par toutes les instances
  static int totalCount = 0;

  // Variable d'instance : indépendante pour chaque instance
  String label;

  Counter(this.label) {
    // Chaque fois qu'une instance est créée, le compteur statique est incrémenté de 1
    totalCount++;
  }

  // Méthode statique : appelée via le nom de la classe
  static void printTotal() {
    print('EXEMPLE nombre total d’instances : $totalCount');
  }

  // Les méthodes statiques sont souvent utilisées pour des fonctions utilitaires
  static bool isValidLabel(String label) {
    return label.isNotEmpty && label.length <= 20;
  }
}

void main() {
  // Méthode statique : appelée directement via le nom de la classe, aucune création d’instance requise
  print('Le libellé est valide : ${Counter.isValidLabel('test')}');

  var c1 = Counter('Compteur A');
  Counter.printTotal();  // 1

  var c2 = Counter('Compteur B');
  var c3 = Counter('Compteur C');
  Counter.printTotal();  // 3

  // Variable statique : accessible via le nom de la classe
  print('Nombre final : ${Counter.totalCount}');
}
标签是否有效: true
EXAMPLE 总实例数: 1
EXAMPLE 总实例数: 3
最终计数: 3

Les méthodes statiques ne peuvent pas accéder aux membres d'instance (car il n'y a pas de `this`). Les méthodes statiques conviennent aux fonctions utilitaires et à la logique de fabrique, mais ne les abusez pas—les méthodes statiques ne peuvent pas être redéfinies par les sous-classes, et un usage excessif réduira la testabilité et la flexibilité du code.

autres extensions