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
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
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
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
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
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
// 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
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
// 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
autres extensionsLes 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.