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

// Eine "printable"-Schnittstelle definieren
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

Funktionenextendsimplements
AnzahlbegrenzungKann nur von einer erbenKann mehrere implementieren
MethodenimplementierungErbt die Implementierung der ElternklasseMuss alle Methoden selbst implementieren
KonstruktorKann super() aufrufenErbt keine Konstruktoren
AnwendungsfallEine "ist-ein"-BeziehungEin 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

// Mehrere Verhaltens-Interfaces definieren
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

// Verwendung des Schlüsselworts mixin zur Definition
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

// Basisklasse
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

mixin Jumpable {
  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