Grundlagen des Polymorphismus

Teil des Abschnitts Objektorientierte Programmierung der Dart-Journey von Coddy. Lektion 57 von 110.

Polymorphismus bedeutet „viele Formen“ – es ist die Fähigkeit, Objekte verschiedener Klassen über eine gemeinsame Schnittstelle zu behandeln. Wenn Sie eine Referenz einer Elternklasse haben, kann diese auf jedes Objekt einer Kindklasse verweisen, und die korrekte Methode wird basierend auf dem tatsächlichen Objekttyp aufgerufen.

Das ist leistungsstark, da Sie Code schreiben können, der mit dem Elterntyp arbeitet und dennoch automatisch alle Kindtypen korrekt verarbeitet:

class Animal {
  void speak() => print('Some sound');
}

class Dog extends Animal {
  @override
  void speak() => print('Woof!');
}

class Cat extends Animal {
  @override
  void speak() => print('Meow!');
}

void main() {
  Animal myPet = Dog();  // Elterntyp, Kindobjekt
  myPet.speak();  // Ausgabe: Woof!
  
  myPet = Cat();  // Dieselbe Variable, anderes Objekt
  myPet.speak();  // Ausgabe: Meow!
}

Die Variable myPet ist als Animal deklariert, aber sie enthält ein Dog oder Cat. Wenn speak() aufgerufen wird, schaut Dart zur Laufzeit auf den tatsächlichen Objekttyp und ruft die entsprechende überschriebene Methode auf.

Dies ermöglicht es Ihnen, flexible Funktionen zu schreiben, die mit jeder Unterklasse funktionieren:

void makeAllSpeak(List<Animal> animals) {
  for (var animal in animals) {
    animal.speak();  // Jedes Tier spricht auf seine eigene Weise
  }
}

void main() {
  var pets = [Dog(), Cat(), Dog()];
  makeAllSpeak(pets);
  // Ausgabe: Woof! Meow! Woof!
}

Die Funktion muss nichts über Dog oder Cat wissen – sie arbeitet einfach mit Animal. Dies macht Ihren Code erweiterbarer, da das Hinzufügen neuer Tierarten keine Änderungen an bestehenden Funktionen erfordert.

Aufgabe

Einfach

Lass uns ein Musikinstrumentensystem erstellen, das Polymorphismus in Aktion demonstriert. Du erstellst eine übergeordnete Instrument-Klasse und mehrere Instrumenttypen und schreibst anschließend eine Funktion, die jede Sammlung von Instrumenten gemeinsam spielen lassen kann – ohne deren spezifische Typen zu kennen.

Du organisierst deinen Code in zwei Dateien:

instruments.dart: Definiere hier deine Instrumenthierarchie:
- Eine Instrument-Klasse mit einer String name-Eigenschaft und einem Konstruktor. Füge eine Methode play() hinzu, die [name] makes a sound ausgibt.
- Eine Guitar-Klasse, die Instrument erweitert und play() überschreibt, um [name] strums melodically auszugeben.
- Eine Drum-Klasse, die Instrument erweitert und play() überschreibt, um [name] beats rhythmically auszugeben.
- Eine Piano-Klasse, die Instrument erweitert und play() überschreibt, um [name] plays harmoniously auszugeben.
Erstelle außerdem eine Funktion performConcert(List<Instrument> instruments), die Concert begins! ausgibt, anschließend die Liste durchläuft und für jedes Instrument play() aufruft und schließlich Concert ends! ausgibt.
main.dart: Importiere deine Instrumentdatei und demonstriere Polymorphismus, indem du eine gemischte Band erstellst:
- Erstelle eine Liste des Typs List<Instrument>, die eine Guitar namens 'Acoustic', eine Drum namens 'Snare' und ein Piano namens 'Grand' enthält.
- Übergib diese Liste an performConcert().

Beachte, wie performConcert() mit dem übergeordneten Typ Instrument arbeitet, während jedes Instrument auf seine eigene einzigartige Weise spielt. Das ist Polymorphismus – derselbe Methodenaufruf erzeugt je nach tatsächlichem Objekttyp ein unterschiedliches Verhalten.

Erwartete Ausgabe:

Concert begins!
Acoustic strums melodically
Snare beats rhythmically
Grand plays harmoniously
Concert ends!

Probier es selbst

import 'instruments.dart';

void main() {
  // TODO: Erstelle eine List<Instrument>, die Folgendes enthält:
  // - Eine Guitar namens 'Acoustic'
  // - Eine Drum namens 'Snare'
  // - Ein Piano namens 'Grand'
  
  
  // TODO: Rufe performConcert() mit deiner Liste von Instrumenten auf
  
}