JAVA-Designmuster-Fabrikmuster (einfaches Fabrikmuster + Fabrikmethodenmuster)

In der objektorientierten Programmierung ist die häufigste Methode ein neuer Operator zum Generieren einer Objektinstanz, und der neue Operator wird zum Erstellen einer Objektinstanz verwendet. In einigen Fällen führt die direkte Generierung von Objekten durch den neuen Operator jedoch zu Problemen. Beispielsweise erfordert die Erstellung vieler Objekttypen eine Reihe von Schritten: Möglicherweise müssen Sie die Anfangseinstellungen des Objekts berechnen oder abrufen und auswählen, welche Unterobjektinstanz generiert werden soll . In diesen Fällen ist die Erstellung eines neuen Objekts ein „Prozess“ und nicht nur ein Vorgang, wie ein Zahnradgetriebe in einer größeren Maschine.

Problem mit dem Muster: Wie können Sie eine Objektinstanz einfach und bequem erstellen, ohne sich um die Details und den komplexen Prozess der Konstruktion einer Objektinstanz kümmern zu müssen?

Lösung: Bauen Sie eine Fabrik, um Objekte herzustellen

Umsetzung:

1 Einführung
1) Es gibt noch kein Fabrikzeitalter: Wenn es keine industrielle Revolution gibt, Wenn ein Kunde ein BMW-Auto möchte, besteht der allgemeine Ansatz darin, dass der Kunde ein BMW-Auto baut und es dann nutzt.
2) Einfaches Fabrikmodell: Später kam die industrielle Revolution. Benutzer müssen keine BMW-Autos erstellen. Weil der Kunde eine Fabrik hat, die ihm bei der Herstellung von BMW hilft. Diese Fabrik kann jedes Auto bauen, das er möchte. Ich möchte zum Beispiel ein Auto der 320i-Serie. Die Fabrik stellt diese Fahrzeugserie her. Das heißt, die Fabrik kann Produkte herstellen.
3) Fabrikmodell-Ära: Um die Kunden zufrieden zu stellen, gibt es immer mehr BMW-Autoserien wie 320i, 523i, 30li und andere Serien. Eine Fabrik kann nicht alle BMW-Serien herstellen. Infolgedessen wurden mehrere spezifische Fabriken getrennt. Jede einzelne Pflanze bildet eine Art Serie. Das heißt, eine bestimmte Fabrikklasse kann nur ein bestimmtes Produkt erstellen. Aber das BMW-Werk ist immer noch eine Abstraktion. Sie müssen eine bestimmte Fabrik für die Produktion des Autos benennen.

4) Die Ära des abstrakten Fabrikmodells: Da die Kundenanforderungen immer höher werden, müssen BMW-Autos mit Klimaanlagen ausgestattet werden. Also begann die Fabrik mit der Produktion von BMW-Autos und den erforderlichen Klimaanlagen.

Am Ende muss der Kunde dem BMW-Verkäufer nur sagen: Ich möchte ein 523i-Klimaauto, und der Verkäufer wird ihm direkt ein 523i-Klimaauto geben. Anstatt selbst ein 523i klimatisiertes BMW-Auto zu bauen

Dies ist das Werksmodell.

2. Klassifizierung
Das Factory-Muster stellt hauptsächlich eine Übergangsschnittstelle zum Erstellen von Objekten bereit, um den spezifischen Prozess der Objekterstellung abzuschirmen und zu isolieren und den Zweck der Verbesserung der Flexibilität zu erreichen.
Das Fabrikmuster kann in drei Kategorien unterteilt werden:

1) Einfaches Fabrikmuster (Einfache Fabrik)
2) Fabrikmethodenmuster (Fabrikmethode)
3) Abstraktes Fabrikmuster (Abstrakt Factory)

Diese drei Modi werden nach und nach von oben nach unten abstrahiert und allgemeiner.
GOF unterteilt Fabrikmuster im Buch „Design Patterns“ in zwei Kategorien: Factory Method Pattern (Factory Method) und Abstract Factory Pattern (Abstract Factory).

Stellen Sie sich das Simple Factory-Muster (Simple Factory) als Sonderfall des Factory-Methodenmusters vor, und beide werden in dieselbe Kategorie eingeordnet.

3. Unterschiede
Factory-Methodenmuster:
Eine abstrakte Produktklasse kann mehrere spezifische Produktklassen ableiten.
Eine abstrakte Factory-Klasse kann mehrere konkrete Factory-Klassen ableiten.
Jede spezifische Fabrikklasse kann nur eine Instanz einer bestimmten Produktklasse erstellen.
Abstraktes Fabrikmuster:
Mehrere abstrakte Produktklassen, jede abstrakte Produktklasse kann mehrere spezifische Produktklassen ableiten.
Eine abstrakte Factory-Klasse kann mehrere konkrete Factory-Klassen ableiten.
Jede spezifische Fabrikklasse kann mehrere Instanzen bestimmter Produktklassen erstellen.
Unterschied:
Das Fabrikmethodenmuster hat nur eine abstrakte Produktklasse, während das abstrakte Fabrikmuster mehrere hat.
Die konkrete Factory-Klasse des Factory-Methodenmusters kann nur eine Instanz der spezifischen Produktklasse erstellen, während das abstrakte Factory-Muster mehrere Instanzen erstellen kann.
Beide können verwendet werden.

4. Einfaches Factory-Muster
Erstellen Sie eine Factory (eine Funktion oder eine Klassenmethode), um neue Objekte zu erstellen.
Einführung in die Distributionsbeschreibung: von Grund auf. Kunden bauen ihre eigenen BMW-Autos und nutzen sie dann.

public class BMW320 {  
    public BMW320(){  
        System.out.println("制造-->BMW320");  
    }  
}  
  
public class BMW523 {  
    public BMW523(){  
        System.out.println("制造-->BMW523");  
    }  
}  
  
public class Customer {  
    public static void main(String[] args) {  
        BMW320 bmw320 = new BMW320();  
        BMW523 bmw523 = new BMW523();  
    }  
}

Kunden müssen wissen, wie man ein Auto erstellt, und der Kunde und das Auto sind eng miteinander verbunden. Um die Kopplung zu verringern, ist die Fabrikklasse erschienen Um ein Auto zu erstellen, werden alle Betriebsdetails in der Fabrik platziert und das gewünschte BMW-Modell übergeben, ohne die Details der Erstellung kennen zu müssen 🎜 >

Das heißt, wir erstellen eine Factory-Klassenmethode, um neue Objekte zu erstellen. Wie im Bild gezeigt:

Produktkategorie:

abstract class BMW {  
    public BMW(){  
          
    }  
}  
  
public class BMW320 extends BMW {  
    public BMW320() {  
        System.out.println("制造-->BMW320");  
    }  
}  
public class BMW523 extends BMW{  
    public BMW523(){  
        System.out.println("制造-->BMW523");  
    }  
}

Fabrikkategorie:

public class Factory {  
    public BMW createBMW(int type) {  
        switch (type) {  
          
        case 320:  
            return new BMW320();  
  
        case 523:  
            return new BMW523();  
  
        default:  
            break;  
        }  
        return null;  
    }  
}

Kundenkategorie:

public class Customer {  
    public static void main(String[] args) {  
        Factory factory = new Factory();  
        BMW bmw320 = factory.createBMW(320);  
        BMW bmw523 = factory.createBMW(523);  
    }  
}

   简单工厂模式又称静态工厂方法模式。重命名上就可以看出这个模式一定很简单。它存在的目的很简单：定义一个用于创建对象的接口。 
      先来看看它的组成： 
         1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，用来创建产品
         2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。         
         3) 具体产品角色：工厂类所创建的对象就是此角色的实例。在Java中由一个具体类实现。 
        
        下面我们从开闭原则（对扩展开放；对修改封闭）上来分析下简单工厂模式。当客户不再满足现有的车型号的时候，想要一种速度快的新型车，只要这种车符合抽象产品制定的合同，那么只要通知工厂类知道就可以被客户使用了。所以对产品部分来说，它是符合开闭原则的；但是工厂部分好像不太理想，因为每增加一种新型车，都要在工厂类中增加相应的创建业务逻辑（createBMW(int type)方法需要新增case），这显然是违背开闭原则的。可想而知对于新产品的加入，工厂类是很被动的。对于这样的工厂类，我们称它为全能类或者上帝类。 
        我们举的例子是最简单的情况，而在实际应用中，很可能产品是一个多层次的树状结构。由于简单工厂模式中只有一个工厂类来对应这些产品，所以这可能会把我们的上帝累坏了，也累坏了我们这些程序员。
        于是工厂方法模式作为救世主出现了。 工厂类定义成了接口,而每新增的车种类型,就增加该车种类型对应工厂类的实现,这样工厂的设计就可以扩展了,而不必去修改原来的代码。
五、工厂方法模式 
        工厂方法模式去掉了简单工厂模式中工厂方法的静态属性，使得它可以被子类继承。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。 
工厂方法模式组成： 
       1)抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。 
       2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。 
       3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。 
       4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。 
       工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的“上帝类”。正如上面所说，这样便分担了对象承受的压力；而且这样使得结构变得灵活 起来——当有新的产品产生时，只要按照抽象产品角色、抽象工厂角色提供的合同来生成，那么就可以被客户使用，而不必去修改任何已有 的代码。可以看出工厂角色的结构也是符合开闭原则的！ 

代码如下： 

产品类：

abstract class BMW {  
    public BMW(){  
          
    }  
}  
public class BMW320 extends BMW {  
    public BMW320() {  
        System.out.println("制造-->BMW320");  
    }  
}  
public class BMW523 extends BMW{  
    public BMW523(){  
        System.out.println("制造-->BMW523");  
    }  
}

创建工厂类：

interface FactoryBMW {  
    BMW createBMW();  
}  
  
public class FactoryBMW320 implements FactoryBMW{  
  
    @Override  
    public BMW320 createBMW() {  
  
        return new BMW320();  
    }  
  
}  
public class FactoryBMW523 implements FactoryBMW {  
    @Override  
    public BMW523 createBMW() {  
  
        return new BMW523();  
    }  
}

客户类：

public class Customer {  
    public static void main(String[] args) {  
        FactoryBMW320 factoryBMW320 = new FactoryBMW320();  
        BMW320 bmw320 = factoryBMW320.createBMW();  
  
        FactoryBMW523 factoryBMW523 = new FactoryBMW523();  
        BMW523 bmw523 = factoryBMW523.createBMW();  
    }  
}

 工厂方法模式仿佛已经很完美的对对象的创建进行了包装，使得客户程序中仅仅处理抽象产品角色提供的接口，但使得对象的数量成倍增长。当产品种类非常多时，会出现大量的与之对应的工厂对象，这不是我们所希望的。