Schnelles und einfaches Verständnis der drei Fabrikmuster von Java

Die drei Factory-Muster von Java sind schnell und einfach zu verstehen ob jedes Mal instanziiert werden soll. Welche Schemaklasse verwendet werden soll. Es definiert eine Schnittstelle zum Erstellen von Objekten und Unterklassen entscheiden, welche Klasse instanziiert werden soll.


//Definieren Sie die öffentliche Schnittstelle Fruit { void plantFruit(); void void eatFruit(); //Apple implementiert die öffentliche Klasse Fruit { @Override public void plantFruit() { System .out.println("Äpfel anbauen."); } @Override public void eatFruit() { System.out.println("Äpfel essen."); //Orange implementiert die Fruchtschnittstelle. Öffentliche Klasse Orange implementiert Fruit { @Override public void plantFruit() { System.out.println("Orangen pflanzen."); } @Override public void eatFruit() { System.out.println("Orangen essen."); public class FruitFactory { public static Fruit getFurit(String FruitName) { //Einfacher Factory-Modus if (fruitName.equalsIgnoreCase("Apple")) { // Wenn es ein Apfel ist, gib eine Apple-Instanz zurück return new Apple( } else if (fruitName.equalsIgnoreCase ("Orange")) { // Wenn es eine Orange ist, gib die orangefarbene Instanz zurück return new Orange(); } else { return null } } } //Test class public class Test { public static void main(String[]args) { //Einfachen Factory-Modus aufrufen FruitFactory.getFurit("Orange").plantFruit(); Ausgabe: Orangen pflanzen.

Zusammenfassung

A: Wenn ich Äpfel kaufen möchte, muss ich nur eine Anfrage an die Fabrikrolle (FruitFactory) stellen. Nach Erhalt der Anfrage bestimmt die Factory-Rolle, welches Produkt erstellt und bereitgestellt werden soll.
B: Aber für die Fabrikrolle (FruitFactory) ist das Hinzufügen neuer Produkte (z. B. das Hinzufügen von Erdbeeren) ein schmerzhafter Prozess. Die Fabrikrolle muss jedes Produkt kennen, wissen, wie es hergestellt wird und wann es den Kunden bereitgestellt werden muss. Mit anderen Worten: Die Akzeptanz neuer Produkte bedeutet, die Fabrik zu verändern.
C: Daher ist die Offenheit dieses einfachen Fabrikmodells relativ gering.




================================== = =======================

2. Factory-Methodenmuster (Factory-Methode)
Delegiert die Erstellung von Objekten Dies erfolgt durch eine in der übergeordneten Klasse definierte Standardmethode und nicht durch deren Konstruktor. Es liegt an der jeweiligen Unterklasse, zu entscheiden, welche Art von Objekt erstellt werden soll.


//Definieren Sie die öffentliche Schnittstelle Fruit { void plantFruit(); void void eatFruit(); //Apple implementiert die öffentliche Klasse Fruit { @Override public void plantFruit() { System .out.println("Äpfel anbauen."); } @Override public void eatFruit() { System.out.println("Äpfel essen."); //Orange implementiert die Fruchtschnittstelle. Öffentliche Klasse Orange implementiert Fruit { @Override public void plantFruit() { System.out.println("Orangen pflanzen."); } @Override public void eatFruit() { System.out.println("Orangen essen."); ([b ]Hinweis: Diese Factory ist als Schnittstelle deklariert und verfügt über eine gute Skalierbarkeit[/b]) public interface FactoryMethod { /*** Werksmethode*/ Fruit getFruit( //Definieren Sie den Prozess zum Erhalten von Früchten} // Apple-Implementierung der öffentlichen Klasse Fruit Factory getApple implementiert FactoryMethod{ @Override public Fruit getFruit() { // TODO Automatisch generierter Methoden-Stub return new Apple(); } } // Oranges Implementierung der öffentlichen Klasse Fruit Factory getOrange implementiert FactoryMethod { @ Override public Fruit getFruit() { // TODO Automatisch generierter Methoden-Stub return new Orange(); } //Testklasse public class TestFactoryMethod { public static void main(String[] args) { getApple apple = new getApple(); apple .getFruit().eatFruit(); } } Ausgabe: Apfel essen.

Zusammenfassung:
A: Der strukturelle Unterschied zwischen dem Fabrikmethodenmuster und dem einfachen Fabrikmuster ist offensichtlich. Der Kern des Factory-Methodenmusters ist eine abstrakte Factory-Klasse, während das einfache Factory-Muster den Kern auf einer konkreten Klasse platziert. Das Factory-Methodenmuster ermöglicht es vielen konkreten Factory-Klassen, das Erstellungsverhalten der abstrakten Factory-Klasse zu erben, wodurch es zu einer Synthese mehrerer einfacher Factory-Muster wird und so das einfache Factory-Muster populär wird.
B: Das Fabrikmethodenmuster kann nach der Degeneration dem einfachen Fabrikmuster sehr ähnlich werden. Stellen Sie sich vor, wenn Sie sehr sicher sind, dass ein System nur eine konkrete Fabrikklasse benötigt, dann könnten Sie die abstrakte Fabrikklasse genauso gut mit der konkreten Fabrikklasse zusammenführen. Da es ohnehin nur eine bestimmte Factory-Klasse gibt, können Sie die Factory-Methode auch in eine statische Methode ändern. Zu diesem Zeitpunkt erhalten Sie das einfache Factory-Muster.
C: Wenn Sie eine neue Frucht hinzufügen müssen, müssen Sie nur eine neue Fruchtklasse und die entsprechende Fabrikklasse hinzufügen. Es besteht keine Notwendigkeit, den Client oder die abstrakte Factory-Rolle oder andere vorhandene konkrete Factory-Rollen zu ändern. Beim Hinzufügen neuer Fruchtkategorien unterstützt dieses System vollständig das „Offen-Geschlossen“-Prinzip.
D: Für den Factory-Methode-Modus gilt dies nur für eine Kategorie (wie in diesem Beispiel Obst), aber wenn wir auch Fleisch kaufen möchten, funktioniert das nicht. Dies erfordert den Abstract Factory-Modus.


======================================== ===== ==================

3. Abstraktes Fabrikmuster (Abstrakte Fabrik)
Das abstrakte Fabrikmuster kann gesagt werden soll eine Erweiterung des einfachen Fabrikmusters sein. Der Hauptunterschied besteht in der Komplexität der Objekte, die erstellt werden müssen.
Im abstrakten Fabrikmuster kann es ein oder mehrere abstrakte Produkte geben, die somit eine oder mehrere Produktfamilien bilden. Bei nur einer Produktfamilie degeneriert das abstrakte Fabrikmuster tatsächlich zum Fabrikmethodenmuster.

//Definieren Sie die öffentliche Schnittstelle Fruit { void plantFruit(); void void eatFruit(); //Apple implementiert die öffentliche Klasse Fruit { @Override public void plantFruit() { System .out.println("Äpfel anbauen."); } @Override public void eatFruit() { System.out.println("Äpfel essen."); //Orange implementiert die Fruchtschnittstelle. Öffentliche Klasse Orange implementiert Fruit { @Override public void plantFruit() { System.out.println("Orangen pflanzen."); } @Override public void eatFruit() { System.out.println("Orangen essen."); Meat Interface Public Interface Meat { void buyMeat(); void eatMeat(); } //Pork implementiert die Schnittstelle public class BigMeat implementiert Meat { @Override public void buyMeat() { System.out.println("Buy Schweinefleisch."); } @Override public void eatMeat() { System.out.println("Iss Schweinefleisch."); } } //Beef-Implementierungsschnittstelle public class CowMeat implementiert Meat{ @Override public void buyMeat() { System.out.println(" Rindfleisch kaufen." ); } @Override public void eatMeat() { System.out.println("Eat Rindfleisch."); } } //Definieren Sie die Verbraucherschnittstelle public interface UserFactory { /*** Fruchtfabrikmethode*/ public Fruit getFruit(Fruit whichFruit); /***Fleischfabrikmethode*/ public Meat getMeat(Meat whichMeat); Überschreiben Sie public Meat getMeat(Meat whichMeat) { return whichMeat; } //Test class public class TestUserFactory { public static void main(String[]args){ Fruit apple=new Apple(); Meat /Consumption User-Instanz User me=new User(); me.getMeat(bigMeat).buyMeat(); Ausgabe: Eat apple. Kaufen Sie Schweinefleisch.

Zusammenfassung:
A: Das abstrakte Fabrikmuster kann eine Schnittstelle zum Kunden bereitstellen, sodass der Kunde mehrere Produktfamilien erstellen kann, ohne den spezifischen Produkttyp angeben zu müssen Objekt. Dies ist der Zweck des abstrakten Fabrikmusters.
B: Das abstrakte Fabrikmuster ist die abstrakteste und allgemeinste Form aller Formen von Fabrikmustern.
C: Der größte Unterschied zwischen dem abstrakten Fabrikmuster und dem Fabrikmethodenmuster besteht darin, dass das Fabrikmethodenmuster auf eine hierarchische Produktstruktur (Obst) abzielt, während das abstrakte Fabrikmuster auf mehrere hierarchische Produktstrukturen (Obst, Fleisch) abzielt. .

Weitere schnelle und leicht verständliche Artikel zu den drei Java-Factory-Modi finden Sie auf der chinesischen PHP-Website!