Factory-Konstruktoren

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

Ein factory constructor ist ein spezieller constructor, der nicht immer eine neue instance erstellt. Im Gegensatz zu regulären constructor kann ein factory constructor eine vorhandene instance, einen Untertyp oder sogar null zurückgeben (wenn nullable). Du deklarierst ihn mit dem factory-Schlüsselwort.

class Logger {
  static final Logger _instance = Logger._internal();
  
  // Privater benannter Konstruktor
  Logger._internal();
  
  // Factory-Konstruktor
  factory Logger() {
    return _instance;
  }
}

Logger log1 = Logger();
Logger log2 = Logger();
print(identical(log1, log2)); // true

In diesem Beispiel gibt der Factory-Konstruktor immer dieselbe Instanz zurück. Unabhängig davon, wie oft du Logger() aufrufst, erhältst du dasselbe Objekt. Dieses Muster wird häufig zur Implementierung von Singletons verwendet.

Factory-Konstruktoren unterscheiden sich in einem wichtigen Punkt von regulären Konstruktoren: Sie haben keinen Zugriff auf this, weil sie möglicherweise überhaupt keine neue Instanz erstellen. Stattdessen müssen sie explizit ein Objekt zurückgeben:

class Shape {
  factory Shape(String type) {
    if (type == 'circle') return Circle();
    if (type == 'square') return Square();
    return Rectangle();
  }
}

class Circle extends Shape { Circle() : super._(); }
class Square extends Shape { Square() : super._(); }
class Rectangle extends Shape { Rectangle() : super._(); }

Factory-Konstruktoren sind nützlich, wenn du die Kontrolle über die Erstellung von Instanzen benötigst, etwa um zwischengespeicherte Objekte zurückzugeben, Objekt-Pools zu implementieren oder anhand von Eingabeparametern zu entscheiden, welchen Untertyp du instanziierst.

Aufgabe

Einfach

Erstellen wir ein Benachrichtigungssystem, das Factory-Konstruktoren verwendet, um verschiedene Arten von Benachrichtigungen anhand einer einfachen String-Eingabe zu erstellen.

Du erstellst zwei Dateien, um deinen Code zu organisieren:

notification.dart: Definiere eine Notification-Klasse, die als Grundlage für alle Benachrichtigungstypen dient. Deine Klasse sollte Folgendes enthalten:
- Ein String message-Feld
- Einen privaten benannten Konstruktor Notification._internal, der die Nachricht initialisiert
- Einen Factory-Konstruktor Notification(String type, String message), der abhängig vom Parameter type verschiedene Benachrichtigungsuntertypen zurückgibt:
  - Wenn type 'email' ist, gib eine EmailNotification zurück
  - Wenn type 'sms' ist, gib eine SMSNotification zurück
  - Andernfalls gib eine PushNotification zurück
- Eine send()-Methode, die Sending: [message] ausgibt

Erstelle in derselben Datei drei Unterklassen, die Notification erweitern:

EmailNotification: Überschreibe send(), sodass Email: [message] ausgegeben wird
SMSNotification: Überschreibe send(), sodass SMS: [message] ausgegeben wird
PushNotification: Überschreibe send(), sodass Push: [message] ausgegeben wird

Jede Unterklasse benötigt einen Konstruktor, der eine message entgegennimmt und sie mit super._internal(message) an die übergeordnete Klasse übergibt.

main.dart: Importiere deine Benachrichtigungsklasse und erstelle mithilfe des Factory-Konstruktors drei Benachrichtigungen:
- Eine E-Mail-Benachrichtigung mit der Nachricht 'Welcome!'
- Eine SMS-Benachrichtigung mit der Nachricht 'Your code is 1234'
- Eine Push-Benachrichtigung mit der Nachricht 'New update available'
Rufe bei jeder Benachrichtigung in der oben aufgeführten Reihenfolge send() auf.

Erwartete Ausgabe:

Email: Welcome!
SMS: Your code is 1234
Push: New update available

Probier es selbst

import 'notification.dart';

void main() {
  // TODO: Erstelle eine E-Mail-Benachrichtigung mit der Nachricht 'Welcome!'
  
  // TODO: Create an SMS notification with message 'Your code is 1234'
  
  // TODO: Create a push notification with message 'New update available'
  
  // TODO: Rufe send() für jede Benachrichtigung der Reihe nach auf
}