Dart-Schnittstellen und Mixins
Obwohl Dart nur Einfachvererbung unterstützt, kann durch Schnittstellen und Mixins flexible mehrfache Code-Wiederverwendung erreicht werden.
Dieses Kapitel führt in die Verwendung von implements für Schnittstellen, Mixin-Code-Wiederverwendung und das Schlüsselwort with ein.
implements: eine Schnittstelle implementieren
In Dart definiert jede Klasse implizit eine Schnittstelle.
Die Verwendung des Schlüsselworts implements ermöglicht es einer Klasse, die Schnittstelle einer anderen Klasse zu implementieren, und sie kann mehrere Schnittstellen implementieren.
Beispiel
class Printable {
// Methoden in einer Schnittstelle haben keine Standardimplementierung
// Implementierer müssen alle Member überschreiben
void printContent() {
// Dieser Methodenrumpf wird ignoriert, wenn implements verwendet wird
}
}
// Eine "savable"-Schnittstelle definieren
class Savable {
void save() {}
}
// Verwende implements, um mehrere Schnittstellen zu implementieren
class Document implements Printable, Savable {
String title;
String content;
Document(this.title, this.content);
// Muss alle von der Printable-Schnittstelle geforderten Methoden implementieren
@override
void printContent() {
print('--- Dokument: $title ---');
print(content);
print('--- BEISPIEL Druckvorgang beendet ---');
}
// Muss alle von der Savable-Schnittstelle geforderten Methoden implementieren
@override
void save() {
print('Dokument "$title" wurde auf der Festplatte gespeichert');
}
}
void main() {
var doc = Document(Dart-Tutorial, 'Dies ist ein Dart-Einführungsleitfaden');
// Polymorphie: Document ist sowohl Printable als auch Savable
Printable printable = doc;
printable.printContent();
Savable savable = doc;
savable.save();
}
--- 文档: Dart 教程 --- 这是一份 Dart 入门指南 --- EXAMPLE 打印结束 --- 文档 "Dart 教程" 已保存到磁盘
Hauptunterschied zwischen implements und extends: extends erbt alle Implementierungen (Methodenkörper) von der Elternklasse, während implements nur die Schnittstellensignatur erbt, wodurch alle Methoden neu implementiert werden müssen. Außerdem kann extends nur von einer Klasse erben, während implements mehrere Schnittstellen implementieren kann.
Vergleich extends vs. implements
| Funktionen | extends | implements |
|---|---|---|
| Anzahlbegrenzung | Kann nur von einer erben | Kann mehrere implementieren |
| Methodenimplementierung | Erbt die Implementierung der Elternklasse | Muss alle Methoden selbst implementieren |
| Konstruktor | Kann super() aufrufen | Erbt keine Konstruktoren |
| Anwendungsfall | Eine "ist-ein"-Beziehung | Ein Vertrag darüber, "was es kann" |
Implementierung mehrerer Interfaces
Dart kann mehrere Interfaces implementieren, was der Hauptweg ist, um die Einschränkung der Einfachvererbung zu durchbrechen.
Beispiel
class Flyable {
void fly() {}
}
class Swimmable {
void swim() {}
}
class Walkable {
void walk() {}
}
// Eine Ente kann fliegen, schwimmen und laufen
class Duck implements Flyable, Swimmable, Walkable {
String name;
Duck(this.name);
@override
void fly() {
print('$name fliegt am Himmel');
}
@override
void swim() {
print('$name schwimmt auf dem Wasser');
}
@override
void walk() {
print('$name watschelt an Land');
}
}
// Ein Fisch kann nur schwimmen
class Fish implements Swimmable {
@override
void swim() {
print('Der Fisch schwimmt im Wasser');
}
}
void main() {
var duck = Duck('BEISPIEL Ente');
// Eine Ente kann mehrere Rollen spielen
(duck as Flyable).fly();
(duck as Swimmable).swim();
(duck as Walkable).walk();
// Typprüfung
print('Kann die Ente fliegen? ${duck is Flyable}');
print('Kann die Ente schwimmen? ${duck is Swimmable}');
var fish = Fish();
print('Kann ein Fisch fliegen? ${fish is Flyable}');
}
EXAMPLE 鸭 在天空中飞翔 EXAMPLE 鸭 在水面上游泳 EXAMPLE 鸭 在陆地上摇摇晃晃地走 鸭子能飞吗? true 鸭子能游吗? true 鱼能飞吗? false
Wiederverwendung von Code durch Mixins
Ein Mixin ist ein Mechanismus zur Wiederverwendung von Code über mehrere Klassen hinweg und löst das Problem, dass "mehrere Klassen dieselben Methoden gemeinsam nutzen müssen, aber nicht für Vererbung geeignet sind."
Verwende das Schlüsselwort mixin, um ein Mixin zu definieren, und das Schlüsselwort with, um es in eine Klasse einzumischen.
Beispiel
mixin Logger {
// Methoden in einem Mixin können von mehreren Klassen wiederverwendet werden
void log(String message) {
print('[${DateTime.now()}] $message');
}
void logError(String message) {
print('[ERROR ${DateTime.now()}] $message');
}
}
mixin TimestampFormatter {
String formatTimestamp(dt) {
return '${dt.year}-${dt.month.toString().padLeft(2, '0')}'
'-${dt.day.toString().padLeft(2, '0')}';
}
}
// Verwende das Schlüsselwort with, um ein Mixin einzubinden
class UserService with Logger, TimestampFormatter {
void createUser(String name) {
log('Benutzer wird erstellt: $name');
var now = DateTime.now();
print('Erstellungszeit: ${formatTimestamp(now)}');
}
}
class OrderService with Logger {
void createOrder(String orderId) {
log('Bestellung wird erstellt: $orderId');
}
void cancelOrder(String orderId) {
logError('Bestellung konnte nicht storniert werden: $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
UserService und OrderService stammen aus unterschiedlichen Geschäftsdomänen, daher eignen sie sich nicht dazu, Logger durch Vererbung gemeinsam zu nutzen.
Durch Mixin können beide Logging-Funktionalität erhalten, ohne sich gegenseitig zu beeinflussen.
Mixins können keine Konstruktoren haben und können nicht instanziiert werden. Ihre Rolle besteht ausschließlich darin, wiederverwendbare Methoden bereitzustellen, ohne eine Zustandsinitialisierung einzubeziehen.
Mixin-Einschränkungen
Mixin kann das Schlüsselwort on verwenden, um einzuschränken, dass es nur von bestimmten Klassentypen verwendet werden darf.
Beispiel
class Animal {
String name;
Animal(this.name);
}
// Dieses Mixin kann nur in Animal und dessen Unterklassen eingemischt werden
mixin FlyableMixin on Animal {
void fly() {
print('$name fliegt!');
}
}
// Bird ist ein Animal, also kann es FlyableMixin verwenden
class Bird extends Animal with FlyableMixin {
Bird(String name) : super(name);
}
// Die folgende Zeile führt zu einem Fehler: Car ist kein Animal, daher kann es FlyableMixin nicht verwenden
// class Car with FlyableMixin {} // Fehler!
void main() {
var bird = Bird('BEISPIEL kleiner Vogel');
bird.fly();
// Methoden in FlyableMixin können auf die Eigenschaft name von Animal zugreifen
print('Der Name des kleinen Vogels: ${bird.name}');
}
EXAMPLE 小鸟 飞起来了! 小鸟的名字: EXAMPLE 小鸟
Vollständige Kombination von class, Mixin, extends und implements
In Dart kann eine Klasse gleichzeitig extends, with und implements verwenden:
Beispiel
void jump() => print('Spring hoch!');
}
mixin Runnable {
void run() => print('Lauf vorwärts!');
}
class Animal {
void breathe() => print('Atmen...');
}
// Erbt von Animal, mischt Jumpable und Runnable ein, implementiert 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('EXAMPLE Player A', 95);
var a2 = Athlete('Player B', 88);
a1.showSkills();
print('${a1.name} vs ${a2.name}: ${a1.compareTo(a2) > 0 ? "A wins" : "B wins"}');
}
呼吸... 跑步前进! 跳起来! EXAMPLE 选手A vs 选手B: A 胜
Vollständige Deklarationsreihenfolge:class Subclass extends Superclass with Mixin1, Mixin2 implements Interface1, Interface2
Weitere Erweiterungen