Abstraktes Fabrikmuster

Was ist ein abstraktes Fabrikmuster?

Abstract Factory Pattern ist ein Erstellungsmuster, das eine Schnittstelle zum Erstellen von Familien verwandter oder abhängiger Objekte bereitstellt, ohne deren konkrete Klassen anzugeben.

Wann sollte man es verwenden?

Verwenden Sie das abstrakte Fabrikmuster, wenn Sie Objektfamilien haben, bei denen erwartet wird, dass Objekte in einer Familie zusammenarbeiten, Sie aber dennoch konkrete Produkte und ihre Fabriken vom Clientcode entkoppeln möchten.

Problem

Wir planen die Entwicklung einer einfachen Themenanwendung, bei der der Kunde je nach Wunsch zwischen heller und dunkler Benutzeroberfläche wählen kann. Wir bereiten drei Komponenten vor: Schaltfläche, Menü und Symbolleiste. Jede Komponente hat ein helles und dunkles Erscheinungsbild.
Natürlich möchten wir sicherstellen, dass alle hellen Theme-Komponenten zusammenarbeiten (wir möchten nicht gleichzeitig die helle Schaltfläche, das dunkle Menü und die helle Symbolleiste anzeigen). Darüber hinaus möchten wir weiterhin die Möglichkeit haben, in Zukunft weitere Themen hinzuzufügen, beispielsweise das Thema „Hoher Kontrast“.

Lösung

1. ThemeApplication
   Das ist unser Kunde. Der Konstruktor erhält eine konkrete Fabrik als Argument, dann erstellt createComponents() entsprechende Komponenten. Der Kunde ist nur auf eine abstrakte Fabrik und abstrakte Produkte angewiesen.

2. ThemeFactory
   Eine Schnittstelle für alle konkreten Themen.

3. Konkrete Themenfabriken
   Stellt die tatsächliche Implementierung für die Methoden von ThemeFactory bereit. Diese Betonfabriken stellen Betonprodukte her.

4. Produktschnittstellen
   Schnittstellen für Komponenten.

5. Betonprodukte
   Definiert spezifisches Verhalten.

Struktur

Implementierung in Java

public interface Button {

    void render();
}

public class DarkButton implements Button{

    @Override
    public void render() {
        System.out.println("Successfully render a dark button");
    }
}

public class LightButton implements Button {

    @Override
    public void render() {
        System.out.println("Successfully render a light button");
    }
}

Sie können den Code für Menü- und Symbolleistenkomponenten auf die gleiche Weise schreiben.

public interface ThemeFactory {

    Button createButton();

    Menu createMenu();

    Toolbar createToolbar();
}

public class DarkThemeFactory implements ThemeFactory {

    @Override
    public Button createButton() {
        return new DarkButton();
    }

    @Override
    public Menu createMenu() {
        return new DarkMenu();
    }

    @Override
    public Toolbar createToolbar() {
        return new DarkToolbar();
    }
}

public class LightThemeFactory implements ThemeFactory {

    @Override
    public Button createButton() {
        return new LightButton();
    }

    @Override
    public Menu createMenu() {
        return new LightMenu();
    }

    @Override
    public Toolbar createToolbar() {
        return new LightToolbar();
    }
}

// This is our client code, notice client sees neither concrete products nor concrete factories
public class ThemeApplication {

    private ThemeFactory themeFactory;
    private Button button;
    private Menu menu;
    private Toolbar toolbar;

    public ThemeApplication(ThemeFactory factory) {
        themeFactory = factory;
        createComponents();
    }

    public void createComponents() {
        button = themeFactory.createButton();
        menu = themeFactory.createMenu();
        toolbar = themeFactory.createToolbar();
    }

    public void renderComponents() {
        button.render();
        menu.render();
        toolbar.render();
    }
}

public class ThemeApplicationTestDrive {

    public static void main (String[] args) {
        ThemeFactory darkFactory = new DarkThemeFactory();
        ThemeApplication app1 = new ThemeApplication(darkFactory);
        app1.renderComponents();
        System.out.println("*******************");

        ThemeFactory lightFactory = new LightThemeFactory();
        ThemeApplication app2 = new ThemeApplication(lightFactory);
        app2.renderComponents();
    }
}

Ausgabe:

Successfully render a dark button
Successfully render a dark menu
Successfully render a dark toolbar
*******************
Successfully render a light button
Successfully render a light menu
Successfully render a light toolbar

Fallstricke

• Komplexer zu implementieren als das Fabrikmuster.
• Das Hinzufügen eines neuen Produkts erfordert Änderungen sowohl in der abstrakten Fabrik als auch in der konkreten Fabrik.

Vergleich mit Fabrikmuster

• Das Fabrikmuster entkoppelt konkrete Produkte vom Client-Code, während das abstrakte Fabrikmuster sowohl konkrete Fabriken als auch konkrete Produkte verbirgt.
• Factory-Muster funktioniert mit einem Produkt und seinen Unterklassen. Im Gegensatz dazu eignet sich das abstrakte Fabrikmuster, wenn erwartet wird, dass mehrere Produkte zusammenarbeiten.

---

Sie können alle Entwurfsmusterimplementierungen hier überprüfen.
GitHub-Repository

---

P.S.
Ich bin neu im Schreiben von Tech-Blogs. Wenn Sie Ratschläge zur Verbesserung meines Schreibens haben oder einen verwirrenden Punkt haben, hinterlassen Sie bitte einen Kommentar!
Vielen Dank fürs Lesen :)

Das obige ist der detaillierte Inhalt vonAbstraktes Fabrikmuster. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!