Interfaces et Mixins Dart
Bien que Dart ne prenne en charge que l'héritage simple, une réutilisation de code multiple et flexible peut être obtenue grâce aux interfaces et aux Mixins.
Ce chapitre présente comment utiliser implements pour les interfaces, la réutilisation de code par mixin et le mot-clé with.
implements : implémenter une interface
En Dart, chaque classe définit implicitement une interface.
L'utilisation du mot-clé implements permet à une classe d'implémenter l'interface d'une autre classe, et elle peut implémenter plusieurs interfaces.
Exemple
class Printable {
// Les méthodes d'une interface n'ont pas d'implémentation par défaut
// Les implémenteurs doivent redéfinir tous les membres
void printContent() {
// Ce corps de méthode est ignoré lorsque implements est utilisé
}
}
// Définir une interface « sauvegardable »
class Savable {
void save() {}
}
// Utilisez implements pour implémenter plusieurs interfaces
class Document implements Printable, Savable {
String title;
String content;
Document(this.title, this.content);
// Doit implémenter toutes les méthodes requises par l'interface Printable
@override
void printContent() {
print('--- Document: $title ---');
print(content);
print('--- EXEMPLE impression terminée ---');
}
// Doit implémenter toutes les méthodes requises par l'interface Savable
@override
void save() {
print('Document "$title" a été enregistré sur le disque');
}
}
void main() {
var doc = Document(Tutoriel Dart, 'Ceci est un guide d'introduction à Dart');
// Polymorphisme : Document est à la fois Printable et Savable
Printable printable = doc;
printable.printContent();
Savable savable = doc;
savable.save();
}
--- 文档: Dart 教程 --- 这是一份 Dart 入门指南 --- EXAMPLE 打印结束 --- 文档 "Dart 教程" 已保存到磁盘
Différence clé entre implements et extends : extends hérite de toutes les implémentations (corps des méthodes) de la classe parente, tandis que implements n'hérite que de la signature de l'interface, ce qui vous oblige à réimplémenter toutes les méthodes. De plus, extends ne peut hériter que d'une seule classe, tandis que implements peut implémenter plusieurs interfaces.
comparaison extends vs implements
| Fonctionnalités | extends | implements |
|---|---|---|
| Limite de quantité | Ne peut hériter que d'une seule | Peut implémenter plusieurs |
| Implémentation de méthode | Hérite de l'implémentation de la classe parente | Doit implémenter toutes les méthodes soi-même |
| Constructeur | Peut appeler super() | N'hérite pas des constructeurs |
| Cas d'utilisation | Une relation « est-un » | Un contrat de « ce qu'il peut faire » |
Implémentation de plusieurs interfaces
Dart peut implémenter plusieurs interfaces, ce qui est le principal moyen de dépasser la limitation de l'héritage simple.
Exemple
class Flyable {
void fly() {}
}
class Swimmable {
void swim() {}
}
class Walkable {
void walk() {}
}
// Un canard peut voler, nager et marcher
class Duck implements Flyable, Swimmable, Walkable {
String name;
Duck(this.name);
@override
void fly() {
print('$name vole dans le ciel');
}
@override
void swim() {
print('$name nage dans l'eau');
}
@override
void walk() {
print('$name se dandine sur la terre ferme');
}
}
// Un poisson ne peut que nager
class Fish implements Swimmable {
@override
void swim() {
print('Le poisson nage dans l'eau');
}
}
void main() {
var duck = Duck('EXEMPLE Canard');
// Un canard peut jouer plusieurs rôles
(duck as Flyable).fly();
(duck as Swimmable).swim();
(duck as Walkable).walk();
// Vérification de type
print('Le canard peut-il voler ? ${duck is Flyable}');
print('Le canard peut-il nager ? ${duck is Swimmable}');
var fish = Fish();
print('Un poisson peut-il voler ? ${fish is Flyable}');
}
EXAMPLE 鸭 在天空中飞翔 EXAMPLE 鸭 在水面上游泳 EXAMPLE 鸭 在陆地上摇摇晃晃地走 鸭子能飞吗? true 鸭子能游吗? true 鱼能飞吗? false
Réutilisation de code par Mixin
Mixin est un mécanisme de réutilisation de code entre plusieurs classes, résolvant le problème où « plusieurs classes doivent partager les mêmes méthodes mais ne se prêtent pas à l'héritage. »
Utilisez le mot-clé mixin pour définir un Mixin, et utilisez le mot-clé with pour l'intégrer à une classe.
Exemple
mixin Logger {
// Les méthodes d'un Mixin peuvent être réutilisées par plusieurs classes
void log(String message) {
print('[${DateTime.now()}] $message');
}
void logError(String message) {
print('[ERROR ${DateTime.now()}] $message');
}
}
mixin TimestampFormatter {
String formatTimestamp(DateTime dt) {
return '${dt.year}-${dt.month.toString().padLeft(2, '0')}'
'-${dt.day.toString().padLeft(2, '0')}';
}
}
// Utilisez le mot-clé with pour intégrer un Mixin
class UserService with Logger, TimestampFormatter {
void createUser(String name) {
log('Création de l’utilisateur : $name');
var now = DateTime.now();
print('Heure de création : ${formatTimestamp(now)}');
}
}
class OrderService with Logger {
void createOrder(String orderId) {
log('Création de la commande : $orderId');
}
void cancelOrder(String orderId) {
logError('Échec de l'annulation de la commande: $orderId');
}
}
void main() {
var userService = UserService();
userService.createUser('example');
var orderService = OrderService();
orderService.createOrder('ORD-001');
orderService.cancelOrder('ORD-001');
}
[2026-06-12 10:30:00.000] 创建用户: example 创建时间: 2026-06-12 [2026-06-12 10:30:00.001] 创建订单: ORD-001 [ERROR 2026-06-12 10:30:00.001] 取消订单失败: ORD-001
User et OrderService proviennent de domaines métier différents, ils ne sont donc pas adaptés pour partager Logger par héritage.
Grâce au Mixin, ils peuvent tous deux acquérir une fonctionnalité de journalisation sans s'affecter mutuellement.
Les Mixins ne peuvent pas avoir de constructeurs et ne peuvent pas être instanciés. Leur rôle est purement de fournir des méthodes réutilisables sans impliquer d'initialisation d'état.
Contraintes de Mixin
Mixin peut utiliser le mot-clé on pour le restreindre à être utilisé uniquement par des types spécifiques de classes.
Exemple
class Animal {
String name;
Animal(this.name);
}
// Ce Mixin ne peut être mélangé que dans Animal et ses sous-classes
mixin FlyableMixin on Animal {
void fly() {
print('$name est en train de voler !');
}
}
// Bird est un Animal, donc il peut utiliser FlyableMixin
class Bird extends Animal with FlyableMixin {
Bird(String name) : super(name);
}
// La ligne suivante produira une erreur : Car n'est pas un Animal, donc il ne peut pas utiliser FlyableMixin
// class Car with FlyableMixin {} // Erreur !
void main() {
var bird = Bird('EXEMPLE Petit Oiseau');
bird.fly();
// Les méthodes dans FlyableMixin peuvent accéder à la propriété name d'Animal
print('Nom du petit oiseau : ${bird.name}');
}
EXAMPLE 小鸟 飞起来了! 小鸟的名字: EXAMPLE 小鸟
Combinaison complète de class, Mixin, extends et implements
En Dart, une classe peut utiliser extends, with et implements en même temps :
Exemple
void jump() => print('Jump up!');
}
mixin Runnable {
void run() => print('Run forward!');
}
class Animal {
void breathe() => print('Breathing...');
}
// Hérite de Animal, utilise les mixins Jumpable et Runnable, implémente Comparable
class Athlete extends Animal
with Jumpable, Runnable
implements Comparable<Athlete> {
String name;
int score;
Athlete(this.name, this.score);
@override
int compareTo(Athlete other) => score.compareTo(other.score);
void showSkills() {
breathe();
run();
jump();
}
}
void main() {
var a1 = Athlete('EXEMPLE Joueur A', 95);
var a2 = Athlete('Joueur B', 88);
a1.showSkills();
print('${a1.name} vs ${a2.name}: ${a1.compareTo(a2) > 0 ? "A gagne" : "B gagne"}');
}
呼吸... 跑步前进! 跳起来! EXAMPLE 选手A vs 选手B: A 胜
Ordre de déclaration complet :class Subclass extends Superclass with Mixin1, Mixin2 implements Interface1, Interface2
autres extensions