Abstraktes Fabrikmuster

Das Abstrakte Fabrikmuster dreht sich um eine Superfabrik, die andere Fabriken erzeugt. Diese Superfabrik wird auch als Fabrik anderer Fabriken bezeichnet. Diese Art von Entwurfsmuster gehört zu den Erzeugungsmustern und bietet eine optimale Möglichkeit, Objekte zu erzeugen.

Im abstrakten Fabrikmuster ist die Schnittstelle dafür verantwortlich, eine Fabrik zusammengehöriger Objekte zu erzeugen, ohne deren Klassen explizit anzugeben. Jede erzeugte Fabrik kann Objekte gemäß dem Fabrikmuster bereitstellen.

Das Abstract-Factory-Muster bietet eine Schnittstelle zum Erstellen einer Reihe zusammengehöriger oder voneinander abhängiger Objekte, ohne konkrete Implementierungsklassen anzugeben. Durch die Verwendung des Abstract-Factory-Musters kann der Client vom Erstellungsprozess konkreter Produkte entkoppelt werden, sodass der Client über die Factory-Schnittstelle eine Produktfamilie erstellen kann.

summary

Absicht

Bietet eine Schnittstelle zum Erstellen einer Reihe zusammengehöriger oder voneinander abhängiger Objekte, ohne deren konkrete Klassen anzugeben.

Hauptsächlich gelöstes Problem

Das Problem der Schnittstellenauswahl.

Anwendbare Szenarien

Wenn das System mehrere zusammengehörige oder abhängige Objekte erstellen muss, ohne konkrete Klassen anzugeben.

Lösung

Innerhalb einer Produktfamilie werden mehrere Produkte definiert, und konkrete Fabriken implementieren die Methoden zum Erstellen dieser Produkte.

Schlüsselcode

Fasst die Erstellungsmethoden mehrerer ähnlicher Produkte in einer Fabrik zusammen.

Anwendungsbeispiel

Angenommen, es gibt verschiedene Arten von Kleiderschränken; jeder Kleiderschrank (konkrete Fabrik) kann nur eine Art von Kleidung aufbewahren (ein vollständiges Set konkreter Produkte), z. B. Businesskleidung, Modekleidung usw. Jedes Kleidungsset enthält bestimmte Oberteile und Hosen (konkrete Produkte). Alle Kleiderschränke sind konkrete Implementierungen der Kleiderschrank-Klasse (abstrakte Fabrik), und alle Oberteile und Hosen implementieren jeweils die Oberteil-Schnittstelle und die Hosen-Schnittstelle (abstrakte Produkte).

Vorteile

Stellt sicher, dass Objekte aus derselben Produktfamilie zusammenarbeiten.
Der Client muss die konkrete Klasse jedes Objekts nicht kennen, was den Code vereinfacht.

Nachteile

Das Erweitern der Produktfamilie ist sehr schwierig. Das Hinzufügen einer neuen Produktfamilie erfordert die Änderung des Codes der abstrakten Fabrik und aller konkreten Fabriken.

Anwendungsfall

Wenn QQ sein Skin ändert, wird das gesamte Set an Skins gemeinsam geändert.
Beim Erstellen plattformübergreifender Anwendungen werden Programme für verschiedene Betriebssysteme generiert.

Hinweise

Das Hinzufügen einer neuen Produktfamilie ist relativ einfach, aber das Hinzufügen einer neuen Produkthierarchie ist schwieriger.

Struktur

Das Abstract-Factory-Muster umfasst die folgenden Hauptrollen:

Abstrakte Fabrik: Deklariert eine Reihe von Methoden zum Erstellen von Produktobjekten, wobei jede Methode einem Produkttyp entspricht. Die abstrakte Fabrik kann eine Schnittstelle oder eine abstrakte Klasse sein.
Konkrete Fabrik: Implementiert die Schnittstelle der abstrakten Fabrik und ist für die Erstellung von Instanzen konkreter Produktobjekte verantwortlich.
Abstraktes Produkt: Definiert eine gemeinsame Schnittstelle oder abstrakte Klasse für eine Gruppe von Produktobjekten und beschreibt die öffentlichen Methoden der Produktobjekte.
Konkretes Produkt: Implementiert die Schnittstelle des abstrakten Produkts und definiert das spezifische Verhalten und die Attribute des konkreten Produkts.

Das Abstract-Factory-Muster umfasst normalerweise eine Familie zusammengehöriger Produkte, und jede konkrete Fabrikklasse ist für die Erstellung der konkreten Produkte in dieser Familie verantwortlich. Der Client erstellt Produktobjekte über die Schnittstelle der abstrakten Fabrik, ohne direkt die Implementierungsklassen der konkreten Produkte zu verwenden.

Implementierung

Wir werdenShapeundColorSchnittstellen und Entitätsklassen erstellen, die diese Schnittstellen implementieren. Der nächste Schritt ist, die abstrakte FabrikklasseAbstractFactory zu erstellen.. Definieren Sie als Nächstes die Fabrikklassen.ShapeFactoryundColorFactory, und diese beiden Fabrikklassen erweitern beideAbstractFactory. Erstellen Sie dann eine Factory-Ersteller-/Generator-KlasseFactoryProducer。

AbstractFactoryPatternDemoKlassenverwendungFactoryProducerUm einAbstractFactoryObjekt zu erhalten. Es wird übergeben anAbstractFactoryÜbergeben Sie ForminformationenShape（CIRCLE / RECTANGLE / SQUARE), um den Typ des benötigten Objekts zu erhalten. Gleichzeitig ruft es auchAbstractFactory aufÜbergeben Sie FarbinformationenColor（RED / GREEN / BLUE), um den Typ des benötigten Objekts zu erhalten.

Schritt 1

Erstellen Sie eine Schnittstelle für Formen.

Shape.java

public interface Shape { void draw(); }

Schritt 2

Erstellen Sie konkrete Klassen, die die Schnittstelle implementieren.

Rectangle.java

Rectangle.java

public class Rectangle implements Shape { @Override public void draw() { System.out.println("Innerhalb der Methode Rectangle::draw()."); } }

Square.java

public class Square implements Shape { @Override public void draw() { System.out.println("Innerhalb der Methode Square::draw()."); } }

Circle.java

public class Circle implements Shape { @Override public void draw() { System.out.println("Innerhalb der Methode Circle::draw()."); } }

Schritt 3

Erstellen Sie eine Schnittstelle für Farben.

Color.java

public interface Color { void fill(); }

Schritt 4

Erstellen Sie konkrete Klassen, die die Schnittstelle implementieren.

Red.java

public class Red implements Color { @Override public void fill() { System.out.println("Innerhalb der Red::fill()-Methode."); } }

Green.java

public class Green implements Color { @Override public void fill() { System.out.println("Innerhalb der Green::fill()-Methode."); } }

Blue.java

public class Blue implements Color { @Override public void fill() { System.out.println("Innerhalb der Blue::fill()-Methode."); } }

Schritt 5

Erstellen Sie eine abstrakte Klasse, um Fabriken für Color- und Shape-Objekte zu erhalten.

AbstractFactory.java

public abstract class AbstractFactory { public abstract Color getColor(String color); public abstract Shape getShape(String shape); }

Schritt 6

Erstelle Factory-Klassen, die AbstractFactory erweitern, und generiere anhand der gegebenen Informationen Objekte von Entitätsklassen.

ShapeFactory.java

public class ShapeFactory extends AbstractFactory { @Override public Shape getShape(String shapeType){ if(shapeType == null){ return null; } if(shapeType.equalsIgnoreCase("CIRCLE")){ return new Circle(); } else if(shapeType.equalsIgnoreCase("RECTANGLE")){ return new Rectangle(); } else if(shapeType.equalsIgnoreCase("SQUARE")){ return new Square(); } return null; } @Override public Color getColor(String color) { return null; } }

ColorFactory.java

public class ColorFactory extends AbstractFactory { @Override public Shape getShape(String shapeType){ return null; } @Override public Color getColor(String color) { if(color == null){ return null; } if(color.equalsIgnoreCase("RED")){ return new Red(); } else if(color.equalsIgnoreCase("GREEN")){ return new Green(); } else if(color.equalsIgnoreCase("BLUE")){ return new Blue(); } return null; } }

Schritt 7

Erstellen Sie eine Klasse zum Erzeugen/Generieren von Fabriken, um Fabriken durch Übergeben von Form- oder Farbinformationen zu erhalten.

FactoryProducer.java

public class FactoryProducer { public static AbstractFactory getFactory(String choice){ if(choice.equalsIgnoreCase("SHAPE")){ return new ShapeFactory(); } else if(choice.equalsIgnoreCase("COLOR")){ return new ColorFactory(); } return null; } }

Schritt 8

Verwenden Sie FactoryProducer, um AbstractFactory zu erhalten, und erhalten Sie Entitätsklassenobjekte, indem Sie Typinformationen übergeben.

AbstractFactoryPatternDemo.java

public class AbstractFactoryPatternDemo { public static void main(String[] args) { //Rufen Sie die Formfabrik ab AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE"); //Rufen Sie das Objekt mit der Form Circle ab Shape shape1 = shapeFactory.getShape("CIRCLE"); //Rufen Sie die draw-Methode von Circle auf shape1.draw(); //Rufen Sie ein Objekt ab, dessen Form Rectangle ist Shape shape2 = shapeFactory.getShape("RECTANGLE"); //Rufe die draw-Methode von Rectangle auf shape2.draw(); //Hole das Objekt mit der Form Square Shape shape3 = shapeFactory.getShape("SQUARE"); //Rufe die draw-Methode von Square auf shape3.draw(); //Hole die Farbfabrik AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR"); //Hole das Objekt mit der Farbe Red Color color1 = colorFactory.getColor("RED"); //Rufe die fill-Methode von Red auf color1.fill(); //Hole das Objekt mit der Farbe Green Color color2 = colorFactory.getColor("GREEN"); //Rufe die fill-Methode von Green auf color2.fill(); //Hole Objekte, deren Farbe Blue ist Color color3 = colorFactory.getColor("BLUE"); //Rufe die fill-Methode von Blue auf color3.fill(); } }

Schritt 9

Führen Sie das Programm aus, geben Sie das Ergebnis aus:

Inside Circle::draw() method.
Inside Rectangle::draw() method.
Inside Square::draw() method.
Inside Red::fill() method.
Inside Green::fill() method.
Inside Blue::fill() method.

Weitere Erweiterungen

EntwurfsmusterSonstiges