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

Classe parente (classe de base, superclasse)
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

class Animal {
  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

class Vehicle {
  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énariosSyntaxeDescription
Appel du constructeur de la classe parente: super(args)Doit être appelé dans la liste d'initialisation
Appel des méthodes de la classe parentesuper.methodName()Peut être appelé dans les méthodes redéfinies de la sous-classe
Accès aux propriétés de la classe parentesuper.propertyNameAccè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

// Le mot-clé abstract déclare une classe abstraite
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

La 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.

autres extensions