Detaillierte Erläuterung des Java-Factory-Methodenmusters

Dieser Artikel vermittelt Ihnen relevantes Wissen über Java, das hauptsächlich Probleme im Zusammenhang mit dem Factory-Methodenmuster vorstellt. Es wird auch als virtuelles Konstruktormuster oder polymorphes Factory-Muster bezeichnet hilft allen.

Empfohlene Studie: „Java-Tutorial“

1. Was ist das Factory-Methodenmuster?

Factory-Methodenmuster: Wird auch als virtuelles Konstruktormuster oder polymorphes Factory-Muster bezeichnet und gehört zum Klassenerstellungsmuster.

Im Factory-Methodenmuster ist die Factory-Elternklasse für die Definition der öffentlichen Schnittstelle zum Erstellen von Produktobjekten verantwortlich, während die Factory-Unterklasse für die Generierung spezifischer Produktobjekte verantwortlich ist. Der Zweck besteht darin, die Instanziierung der Produktklasse zu verzögern zur Factory-Unterklasse Im Prozess abgeschlossen, das heißt, die Factory-Unterklasse wird verwendet, um zu bestimmen, welche spezifische Produktklasse instanziiert werden soll.

Wir wissen, dass die Arbeitsteilung in den heutigen realen Fabriken immer detaillierter und professioneller wird. . In spezialisierten Fabriken werden verschiedene Produkte hergestellt, wodurch die Ära der autarken kleinbäuerlichen Wirtschaft, die den Produktionszyklus der Produkte erheblich verkürzt und die Produktionseffizienz verbessert, vollständig verabschiedet wird. Das Factory-Methodenmuster erfüllt nicht nur das Öffnungs- und Schließprinzip, sondern übernimmt auch die Vorteile des einfachen Factory-Musters.

Beispiel:

In der Coca-Cola-Fabrik im Artikel über einfache Fabrikmuster muss jedes Produkt in dieser Klasse geändert und angepasst werden, und das Fabrikmethodenmuster verfügt jeweils über mehrere Fabriken Wenn die Notwendigkeit besteht, neue Produkte hinzuzufügen, können wir einfach eine neue Fabrik erstellen. Dies entspricht dem Öffnungs- und Schließungsprinzip.

2. Vor- und Nachteile des Factory-Methodenmusters

Vorteile:

• Benutzer müssen nur den Namen der spezifischen Fabrik kennen, um das gewünschte Produkt zu erhalten, ohne den spezifischen Erstellungsprozess des Produkts zu kennen

• Erhöhte Flexibilität. Für die Erstellung neuer Produkte müssen Sie nur noch eine entsprechende Fabrikklasse schreiben

• Ein typisches Entkopplungsframework. Hochrangige Module müssen nur die abstrakte Klasse des Produkts kennen und müssen sich nicht um andere Implementierungsklassen kümmern. Sie erfüllen das Demeter-Gesetz, das Abhängigkeitsinversionsprinzip und das Richter-Substitutionsprinzip. Nachteile:

Die Die Anzahl der Klassen ist leicht zu hoch. Erhöhte Komplexität

• Erhöht die Abstraktion und die Schwierigkeit, das System zu verstehen. Abstrakte Produkte können nur ein Produkt erzeugen ist im nächsten Artikel)

• 3. Struktur und Implementierung des Musters
  Die Struktur besteht aus den folgenden vier Teilen:

• Abstract Factory (Abstrakte Fabrik): Bietet eine Schnittstelle zum Erstellen von Produkten, über die die Der Aufrufer greift auf die Factory-Methode newProduct() der jeweiligen Factory zu.

Concrete Factory (ConcreteFactory): implementiert hauptsächlich die abstrakten Methoden in der Abstract Factory, um die Erstellung spezifischer Produkte abzuschließen ): definiert die Spezifikationen des Produkts und beschreibt die Hauptmerkmale des Produkts und seiner Funktionen

Betonprodukt (ConcreteProduct): implementiert die durch die abstrakte Produktrolle definierte Schnittstelle und wird von der spezifischen Fabrik erstellt. 1:1-Korrespondenz mit der spezifischen Fabrik

Strukturdiagramm:

• 4. Implementierung des Mustercodes der Fabrikmethode

Nehmen wir die Coca-Cola-Fabrik aus dem vorherigen Artikel als Beispiel:

• Die Produkte sind: Coca-Cola, Pepsi-Cola, zuckerfreie Cola

Im einfachen Fabrikmodus gibt es nur eine Coca-Cola-Fabrik, die drei Produkte produzieren kann, im Fabrikmethodenmuster kann es mehrere Fabriken geben, um entsprechende Produkte zu erzeugen:

Abstrakte Fabrik: Koksfabrik (kann als Hauptfabrik verstanden werden)

Pepsi-Cola-Fabrik: Pepsi-Cola erzeugen

Coca-Cola-Fabrik:

Coca-Cola erzeugen

Zuckerfreie Koksfabrik: Zuckerfrei erzeugen Cola

Methode zur Herstellung von Cola:

/**
 *  提供了产品的接口
 */public interface Cola {

    //生产可乐的方法
    public void cola();}

Cola Abstract Factory:

/**
 * 可乐抽象工厂(可以理解成可乐总厂，旗下还有很多分厂)
 */public interface ColaFactory {

    public Cola newCola();}

Methoden zur Herstellung von drei Arten von Cola:
Cola Cola:

/**
 * 产品名称：可乐可乐，实现了产品的接口
 */public class CocaCola implements Cola{

    @Override
    public void cola() {
        System.out.println("开始生产可口可乐");
    }}

Pepsi:

/**
 *
 * 产品名称：百事可乐，实现了产品的接口
 */public class PepsiCola implements Cola{

    @Override
    public void cola() {
        System.out.println("开始生产百事可乐");
    }}

Zuckerfreie Cola:

/*
 * 产品名称：无糖可乐，实现了产品的接口
 */public class SugarFreeCola implements Cola{

    @Override
    public void cola() {
        System.out.println("开始生产无糖可乐");
    }}

Drei Produkte entsprechen drei Fabriken:

Die Fabrik, die Coca-Cola herstellt:

/**
 *
 * 具体工厂1：可口可乐工厂
 */public class CocaColaFactory implements ColaFactory{
    
    @Override
    public Cola newCola() {
        System.out.println("我是可乐工厂下面的可口可乐工厂");
        return new CocaCola();
    }}

Die Fabrik, die Pepsi-Cola herstellt:

/**
 *
 * 具体工厂2：百事可乐工厂
 */public class PepsiColaFactory implements ColaFactory{

    @Override
    public Cola newCola() {
        System.out.println("我是可乐工厂下面的百事可乐工厂");
        return new PepsiCola();
    }}

Die Fabrik, die zuckerfreie Cola herstellt:

/*
 * 具体工厂3：无糖可乐工厂
 */public class SugarFreeColaFactory implements ColaFactory{
    
    @Override
    public Cola newCola() {
        System.out.println("我是可乐工厂下面的无糖可乐工厂");
        return new SugarFreeCola();
    }}

Bisher Es gibt:

Eine Methode zur Herstellung von Koks

Eine Koksfabrik (es gibt mehrere kleine Fabriken unten)

Drei Methoden zur Herstellung von drei Arten von Koks (Implementierung der Coke-Schnittstelle)

Drei Cola-Fabriken (produzieren drei Arten von Cola und implementieren die Cola-Fabrik-Schnittstelle)

Testklasse:

• public class Test {
      public static void main(String[] args) {
  
          try{
  
              //新建一个可乐方法对象
              Cola a;
  
              //新建一个可乐工厂对象
              ColaFactory af;
  
              //告诉可乐工厂，你需要什么可乐，并且通知对应的分工厂
              af = (ColaFactory) new PepsiColaFactory();
              //执行对于生产方法
              a = af.newCola();
              a.cola();
              
          }catch (Exception e ){
              System.out.println(e.getMessage());
          }
      }}

  Wenn ich zum Beispiel jetzt Pepsi brauche, gehe ich in der Pepsi-Fabrik in AF vorbei:

我是可乐工厂下面的无糖可乐工厂
开始生产无糖可乐

如果传入CocaColaFactory：

我是可乐工厂下面的可口可乐工厂
开始生产可口可乐

5、总结

这就是工厂方法模式，和简单工厂模式有所不同，在这个模式内有一个抽象工厂接口，也就是你需要增加新产品后，不需要在原本的工厂内去修改代码，而是直接新建一个工厂，去实现抽象工厂即可，也是符合了开闭原则。

当然缺点也就是工厂多了，管理变得复杂，也增加了系统的抽象性和理解难度，而且抽象产品只能生产一种产品，但是此弊端可使用抽象工厂模式解决（抽象工厂模式在下一篇文章）

推荐学习：《java教程》

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung des Java-Factory-Methodenmusters. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!