Java-Entwurfsmuster – Werksentwurfsmuster

Factory-Modus: Wird hauptsächlich zum Instanziieren von Klassen mit einer gemeinsamen Schnittstelle verwendet. Der Factory-Modus kann dynamisch bestimmen, welche Klasse instanziiert werden soll.
Formen des Fabrikmusters
Das Fabrikmuster verwendet hauptsächlich die folgenden Formen:
1: Einfache Fabrik.
2: Fabrikmethode.
3: Abstrakte Fabrik.

Einfache Fabrik
Auch als statische Fabrik bezeichnet, handelt es sich um die einfachste Struktur unter den drei Zuständen des Fabrikmusters. Es gibt hauptsächlich eine statische Methode, die Parameter akzeptiert und basierend auf den Parametern entscheidet, Instanzen verschiedener Klassen zurückzugeben, die dieselbe Schnittstelle implementieren. Schauen wir uns ein konkretes Beispiel an:
Angenommen, eine Fabrik produziert Waschmaschinen, Kühlschränke, Klimaanlagen usw.
Lassen Sie uns zunächst eine gemeinsame Produktschnittstelle für alle Produkte definieren

public interface Product{}

Dann müssen wir alle Produkte dieser Fabrik herstellen und diese Schnittstelle implementieren

public class Washer implements Product{ 
   public Washer(){ 
       System.out.println("洗衣机被制造了"); 
   } 
} 
 
public class Icebox implements Product{ 
   public Icebox(){ 
       System.out.println("冰箱被制造了"); 
   } 
} 
 
public class AirCondition implements Product{ 
   public Icebox(){ 
       System.out.println("空调被制造了"); 
   } 
}

Als nächstes schreiben wir eine Fabrikklasse, die dafür verantwortlich ist, die oben genannten Produkte zu produzieren

public class SimpleFactory { 
     
    public static Product factory(String productName) throws Exception{ 
        if(productName.equals("Washer")){ 
            return new Washer(); 
        }else if(productName.equals("Icebox")){ 
            return new Icebox(); 
        }else if(productName.equals("AirCondition")){ 
            return new AirCondition(); 
        }else{ 
            throw new Exception("没有该产品"); 
        } 
    } 
}

Nun, mit dieser Fabrikklasse können wir beginnen, Bestellungen aufzugeben, die auf der Grundlage verschiedener Auftragsklassen entscheiden, welche Produkte hergestellt werden sollen.

public static void main(String[] args) { 
    try { 
              SimpleFactory.factory("Washer"); 
              SimpleFactory.factory("Icebox"); 
              SimpleFactory.factory("AirCondition"); 
            } catch (Exception e) { 
        e.printStackTrace(); 
    } 
}

Wie aus dem obigen Code ersichtlich ist, ist der Kern der einfachen Fabrik eine SimpleFactory-Klasse. Sie verfügt über die erforderlichen logischen Beurteilungsfähigkeiten und das Recht, alle Produkte zu erstellen. Wir müssen ihm nur die Bestellung aufgeben und schon bekommen wir das gewünschte Produkt. Dies scheint sehr praktisch zu sein.
Aber tatsächlich weist diese SimpleFactory viele Einschränkungen auf. Jedes Mal, wenn wir ein neues Produkt hinzufügen möchten, müssen wir zunächst den Originalcode von SimpleFactory ändern. Zweitens: Wenn wir viele, viele Produkte haben und es komplexe hierarchische Beziehungen zwischen den Produkten gibt, muss diese Klasse über komplexe logische Beurteilungsfähigkeiten verfügen, und die Menge ihres Codes wird weiter zunehmen, was eine schreckliche Belastung für die zukünftige Wartung darstellt ...
Außerdem ist das gesamte System stark von der SimpleFactory-Klasse abhängig. Sobald ein Problem mit der SimpleFactory-Klasse auftritt, geht das System in einen nicht funktionierenden Zustand über. .
Die oben genannten Mängel werden in den anderen beiden Zuständen des Werksmodus behoben.

Factory-Methode
Der obige Code sagt uns, dass die einfache Factory nicht einfach ist. Sie ist der Kern des gesamten Modells. Sobald etwas schief geht, ist das gesamte Modell betroffen. Um Risiken zu reduzieren und uns auf zukünftige Wartungs- und Erweiterungsarbeiten vorzubereiten, müssen wir es umgestalten und Fabrikmethoden einführen.
Die Factory-Methode definiert eine Schnittstelle für die Factory-Klasse und verwendet Polymorphismus, um die Funktion der Factory-Klasse abzuschwächen. Das Folgende ist die Definition der Factory-Schnittstelle:

public interface Factory{ 
  public Product create(); 
} 
我们再来定义一个产品接口
public interface Product{} 
一下是实现了产品接口的产品类
public class Washer implements Product{ 
   public Washer(){ 
       System.out.println("洗衣机被制造了"); 
   } 
} 
 
public class Icebox implements Product{ 
   public Icebox(){ 
       System.out.println("冰箱被制造了"); 
   } 
} 
 
public class AirCondition implements Product{ 
   public Icebox(){ 
       System.out.println("空调被制造了"); 
   } 
} 
接下来，就是工厂方法的核心部分，也就是具体创建产品对象的具体工厂类，
//创建洗衣机的工厂 
public class CreateWasher implements Factory{ 
    public Product create(){ 
          return new Washer(); 
    } 
} 
 
//创建冰箱的工厂 
public class CreateIcebox implements Factory{ 
    public Product create(){ 
          return new Icebox(); 
    } 
} 
 
//创建空调的工厂 
public class CreateAirCondition implements Factory{ 
    public Product create(){ 
          return new AirCondition(); 
    } 
}

Erstellen Sie Produktobjekte von oben. Aus dem Code ist ersichtlich, dass der Hauptunterschied zwischen der Factory-Methode und der einfachen Factory darin besteht, dass die einfache Factory alle Funktionen zum Erstellen von Produkten in einer Klasse zusammenfasst, während die Factory-Methode verschiedene Produkte in verschiedenen Factorys ablegt Klassen, die die Factory-Schnittstelle implementieren, sodass die anderen Factory-Klassen weiterhin normal funktionieren können, ohne sich gegenseitig zu beeinflussen. Wenn Sie in Zukunft neue Produkte hinzufügen, müssen Sie nur eins hinzufügen Neue Factory-Klasse, die die Factory-Schnittstelle implementiert, um dies zu erreichen, ohne den vorhandenen Code zu ändern. Aber die Fabrikmethode hat auch ihre Grenzen, das heißt, wenn die Produkte, mit denen wir konfrontiert sind, komplexe hierarchische Strukturen aufweisen, stellt die Fabrik beispielsweise auch Mobiltelefonprodukte her Hauptproduktfamilien: Diese beiden Familien enthalten eine große Anzahl von Produkten, und jedes Produkt verfügt über mehrere Modelle, wodurch ein komplexer Produktbaum entsteht. Wenn Sie die Factory-Methode verwenden, um dieses Produktfamiliensystem zu entwerfen, müssen Sie für jedes Produktmodell eine entsprechende Factory-Klasse erstellen. Wenn es Hunderte oder sogar Tausende von Produkten gibt, muss es auch Hunderte oder Tausende entsprechender Factory-Klassen geben. Dies hat zur legendären Klassenexplosion geführt, die einfach eine Katastrophe für zukünftige Wartung ist...

Abstrakte Fabrik (Fabrikmethode)
Abstrakte Fabrik: Die Absicht besteht darin, eine Reihe miteinander verbundener oder voneinander abhängiger Objekte zu erstellen. <>
Ich persönlich denke, dass die abstrakte Fabrik das Konzept des Kategoriemanagements basierend auf der Fabrikmethode einführt....
Die Fabrikmethode wird verwendet, um ein Produkt zu erstellen, das hat sie Keine Klassifizierung Das Konzept der abstrakten Fabrik wird verwendet, um eine Reihe von Produkten zu erstellen. Daher ist die Produktklassifizierung zum Schwerpunkt der abstrakten Fabrik geworden.
Verwenden wir weiterhin das obige Beispiel zur Veranschaulichung:
Alle von der Fabrik hergestellten Produkte werden verwendet Um ihre Modelle zu kennzeichnen, haben Kühlschränke beispielsweise „Kühlschrank-A“ und „Kühlschrank-B“. Ebenso folgen auch andere Produkte dieser Nummerierungsregel, daher gibt es einen Produktstammbaum

Kühlschrank:

Kühlschrank-A

Kühlschrank-B

Waschmaschine:

Waschmaschine-A

Waschen machine -B

Wir können zwei Produktschnittstellen für Kühlschränke und Waschmaschinen definieren, um sie zu klassifizieren,

//洗衣机接口 
public interface Washer{ 
} 
 
//冰箱接口 
public interface Icebox{ 
} 
接着，我们分别创建这两个接口的具体产品
//洗衣机-A 
public class WasherA implements Washer{ 
   public WasherA(){ 
       System.out.println("洗衣机-A被制造了"); 
   } 
} 
 
//洗衣机-B 
public class WasherB implements Washer{ 
   public WasherB(){ 
       System.out.println("洗衣机-B被制造了"); 
   } 
} 
 
//冰箱-A 
public class IceboxA implements Icebox{ 
   public IceboxA(){ 
       System.out.println("冰箱-A被制造了"); 
   } 
} 
 
//冰箱-B 
public class IceboxB implements Icebox{ 
   public IceboxB(){ 
       System.out.println("冰箱-B被制造了"); 
   } 
} 
到此，产品部分我们准备好了，接下来我们来处理工厂部分，我们先来定义工厂行为接口
public interface Factory{ 
       public Washer createWasher(); 
       public Icebox createIcebox(); 
}

Als nächstes erstelle ich eine spezifische Factory-Klasse, basierend auf Auf der Schnittstelle der oben genannten Produkte unterteilen wir die Produkte des Modells A in eine Kategorie, die von einer Fabrik verwaltet wird, und die Produkte des Modells B, die von einer anderen Fabrik verwaltet werden. Gemäß dieser Klassifizierung können wir die folgenden zwei Spezifischen implementieren Fabrikklasse

//创建型号为A的产品工厂 
public class FactoryA implements Factory{ 
       //创建洗衣机-A 
       public Washer createWasher(){ 
            return new WasherA(); 
       } 
 
       //创建冰箱-A 
       public Icebox createIcebox(){ 
            return new IceboxA(); 
       } 
} 
 
//创建型号为B的产品工厂 
public class FactoryB implements Factory{ 
       //创建洗衣机-B 
       public Washer createWasher(){ 
            return new WasherB(); 
       } 
 
       //创建冰箱-B 
       public Icebox createIcebox(){ 
            return new IceboxB(); 
       } 
}

这样，我们的抽象工厂就完成了。有上面可以看出，在运用上我觉得工厂方法和抽象工厂，都有自己的应用场景，并没有什么优劣之分，但在应用抽象工厂之前，要先对创建的对象进行系统的分类，这点很重要，好的产品分类规则能为具体工厂类的选择调用和以后的扩展提供清晰的思路.

更多Java设计模式—工厂设计模式相关文章请关注PHP中文网！