Héritage et polymorphisme Dart
L'héritage est l'une des trois principales caractéristiques de la programmation orientée objet. Il permet à une classe d'être basée sur une autre classe.
Ce chapitre présente l'héritage via extends en Dart, la redéfinition de méthode, le mot-clé super et les classes abstraites.
extends héritage simple
Dart prend en charge l'héritage simple — chaque classe ne peut avoir qu'un seul parent direct.
Mais l'héritage peut être long : une sous-classe hérite d'une classe parente, la classe parente hérite d'une classe grand-parent, et ainsi de suite.
Exemple
class Animal {
String name;
Animal(this.name);
void eat() {
print('$name mange');
}
void sleep() {
print('$name dort');
}
}
// Sous-classe : utilise extends pour hériter d'Animal
class Dog extends Animal {
String breed; // Race
// Le constructeur de la sous-classe doit appeler le constructeur de la classe parente
Dog(String name, this.breed) : super(name);
// Méthodes nouvellement ajoutées par la sous-classe
void bark() {
print('$name ($breed) aboie !');
}
}
void main() {
var dog = Dog('Wangcai', 'Golden Retriever');
// Appeler une méthode héritée de la classe parente
dog.eat();
dog.sleep();
// Appeler la méthode propre à la sous-classe
dog.bark();
// Un objet de la sous-classe est aussi du type de la classe parente
Animal animal = dog; // Dog est un Animal, donc il peut être converti vers le haut
animal.eat();
}
Wangcai is eating. Wangcai is sleeping. Wangcai (Golden Retriever) is barking! Wangcai is eating.
Une sous-classe peut accéder à toutes les variables membres et méthodes non privées de la classe parente.
Les membres privés (commençant par un trait de soulignement) ne sont pas hérités.
Dart n'a pas de mots-clés public, protected ou private. Les membres commençant par un trait de soulignement (_) sont privés à la bibliothèque et ne sont accessibles que dans le même fichier. Cela diffère du contrôle d'accès de Java/C++.
Redéfinition de méthode @override
Une sous-classe peut redéfinir les méthodes de la classe parente pour fournir sa propre implémentation.
L'utilisation de l'annotation @override exprime clairement l'intention de redéfinir, et le compilateur vous aidera à vérifier si la redéfinition est correcte.
Exemple
String name;
Animal(this.name);
// Méthode de la classe parente
void makeSound() {
print('$name a émis des sons');
}
@override
String toString() {
return 'Animal: $name';
}
}
class Cat extends Animal {
Cat(String name) : super(name);
// @override annotation : indique au compilateur que je redéfinis une méthode de la classe parente
@override
void makeSound() {
print('$name miaule~');
}
}
class Duck extends Animal {
Duck(String name) : super(name);
@override
void makeSound() {
print('$name cancane!');
}
}
void main() {
var cat = Cat('Xiaohua');
var duck = Duck('Donald Duck');
cat.makeSound();
duck.makeSound();
// Polymorphisme : la même méthode se comporte différemment pour des objets différents
List<Animal> animals = [
Cat('Mimi'),
Duck('Yaya'),
Cat('Qiuqiu'),
];
print('--- EXAMPLE Zoo ---');
for (var animal in animals) {
animal.makeSound(); // À l'exécution, la méthode du type réel est appelée
}
}
小花 喵喵叫~ 唐老鸭 嘎嘎叫! --- EXAMPLE 动物园 --- 咪咪 喵喵叫~ 鸭鸭 嘎嘎叫! 球球 喵喵叫~
L'exemple ci-dessus démontrele polymorphisme: Pour le même appel de méthode animal.makeSound(), le comportement réellement exécuté dépend du type réel de l'objet.
L'utilisation de l'annotation @override présente deux avantages : d'abord, elle rend l'intention du code plus claire ; ensuite, si la classe parente n'a pas de méthode du même nom (par exemple, une faute de frappe), le compilateur signalera une erreur. Il est recommandé de toujours ajouter @override.
mot-clé super
super représente l'objet de la classe parente. Une sous-classe utilise super pour appeler le constructeur, les méthodes et les propriétés de la classe parente.
Exemple
String brand;
int year;
Vehicle(this.brand, this.year);
void start() {
print('$brand véhicule démarré');
}
void displayInfo() {
print('Marque : $brand, Année : $year');
}
}
class ElectricCar extends Vehicle {
int batteryLevel;
ElectricCar(String brand, int year, this.batteryLevel)
: super(brand, year); // Appeler le constructeur de la classe parente
@override
void start() {
// Appeler une méthode de la classe parente depuis une méthode de sous-classe
super.start(); // Exécuter d'abord la logique de démarrage de la classe parente
print('Niveau de batterie : $batteryLevel%');
print('Le moteur électrique a démarré silencieusement');
}
@override
void displayInfo() {
super.displayInfo(); // Afficher d'abord les informations de base de la classe parente
print('Niveau de batterie : $batteryLevel%'); // Puis compléter avec les informations spécifiques de la sous-classe
}
}
void main() {
var car = ElectricCar('EXEMPLE VE', 2026, 85);
car.start();
print('---');
car.displayInfo();
}
EXAMPLE EV 车辆启动了 电池电量: 85% 电动机无声启动完成 --- 品牌: EXAMPLE EV, 年份: 2026 电池电量: 85%
Récapitulatif des scénarios d'utilisation de super
| Scénarios | Syntaxe | Description |
|---|---|---|
| Appel du constructeur de la classe parente | : super(args) | Doit être appelé dans la liste d'initialisation |
| Appel des méthodes de la classe parente | super.methodName() | Peut être appelé dans les méthodes redéfinies de la sous-classe |
| Accès aux propriétés de la classe parente | super.propertyName | Accès aux variables membres de la classe parente |
Classe abstraite abstract
Une classe abstraite est une classe qui ne peut pas être instanciée directement ; elle ne définit que la spécification de l'interface, la logique concrète étant implémentée par les sous-classes.
Exemple
abstract class Shape {
// Méthode abstraite : pas de corps de méthode, les sous-classes doivent l'implémenter
double getArea();
double getPerimeter();
// Les classes abstraites peuvent également avoir des méthodes concrètes
void describe() {
print('Ceci est une forme, aire : ${getArea()}, périmètre : ${getPerimeter()}');
}
}
class Rectangle extends Shape {
double width;
double height;
Rectangle(this.width, this.height);
@override
double getArea() => width * height;
@override
double getPerimeter() => 2 * (width + height);
}
class Circle extends Shape {
double radius;
Circle(this.radius);
@override
double getArea() => 3.14159 * radius * radius;
@override
double getPerimeter() => 2 * 3.14159 * radius;
}
void main() {
// Shape shape = Shape(); // Erreur ! Les classes abstraites ne peuvent pas être instanciées
var rect = Rectangle(10, 5);
var circle = Circle(7);
rect.describe();
circle.describe();
// Utilisation d'une classe abstraite comme type
List<Shape> shapes = [
Rectangle(3, 4),
Circle(5),
Rectangle(6, 2),
];
print('--- EXEMPLE Statistiques de Shape ---');
double totalArea = 0;
for (var shape in shapes) {
totalArea += shape.getArea();
}
print('Aire totale : ${totalArea.toStringAsFixed(2)}');
}
这是一个形状,面积: 50.0, 周长: 30.0 这是一个形状,面积: 153.93791, 周长: 43.98226 --- EXAMPLE 形状统计 --- 总面积: 108.54
autres extensionsLa valeur essentielle d'une classe abstraite est de "définir un contrat". Elle indique à toutes les sous-classes : vous devez implémenter ces méthodes, sinon la compilation échoue. Cela rend la collaboration en équipe plus sûre — les implémenteurs n'omettront aucune méthode, et les appelants ont la certitude que ces méthodes existent bel et bien.