Detaillierte Analyse des Factory-Methodenmusters in Java

In diesem Artikel werden hauptsächlich die von der Power Node Java Academy zusammengestellten Informationen zur Factory-Methode vorgestellt. Bedürftige können sich darauf beziehen

Definition: Definieren Sie eine Schnittstelle zum Erstellen von Objekten, beispielsweise Unterklassen entscheiden, welche Klasse instanziiert werden soll, und Factory-Methoden verschieben die Instanziierung einer Klasse auf ihre Unterklassen.

Typ: Klassenmuster erstellen

Klassendiagramm:

Factory-Methodenmustercode

interface IProduct { 
  public void productMethod(); 
} 
class Product implements IProduct { 
  public void productMethod() { 
    System.out.println("产品"); 
  } 
} 

interface IFactory { 
  public IProduct createProduct(); 
} 
 
class Factory implements IFactory { 
  public IProduct createProduct() { 
    return new Product(); 
  } 
} 

public class Client { 
  public static void main(String[] args) { 
    IFactory factory = new Factory(); 
    IProduct prodect = factory.createProduct(); 
    prodect.productMethod(); 
  } 
}

Factory-Muster:

Zuerst müssen wir über den Werksmodus sprechen. Das Fabrikmuster wird je nach Abstraktionsgrad in drei Typen unterteilt: das einfache Fabrikmuster (auch statisches Fabrikmuster genannt), das in diesem Artikel beschriebene Fabrikmethodenmuster und das abstrakte Fabrikmuster. Das Factory-Muster ist ein Muster, das häufig in der Programmierung verwendet wird. Seine Hauptvorteile sind:

• kann die Codestruktur klar machen und Änderungen effektiv kapseln. Bei der Programmierung ist die Instanziierung von Produktklassen manchmal komplex und veränderbar. Durch das Factory-Muster wird die Instanziierung des Produkts gekapselt, sodass sich der Aufrufer überhaupt nicht um den Instanziierungsprozess des Produkts kümmern muss Verlassen Sie sich darauf, dass die Fabrik das gewünschte Produkt erhält.

• Bestimmte Produktkategorien für den Anrufer sperren. Wenn Sie das Factory-Muster verwenden, kümmert sich der Anrufer nur um die Produktschnittstelle. Was die spezifische Implementierung angeht, muss sich der Anrufer überhaupt nicht darum kümmern. Selbst wenn die spezifische Implementierung geändert wird, hat dies keine Auswirkungen auf den Aufrufer.

• Kopplung reduzieren. Die Instanziierung einer Produktklasse ist normalerweise sehr kompliziert. Sie hängt von vielen Klassen ab und der Aufrufer muss diese Klassen überhaupt nicht kennen Geben Sie es dem Anrufer zur Verwendung. Für den Aufrufer sind die Klassen, von denen das Produkt abhängt, transparent.

Factory-Methodenmuster:

Aus dem Klassendiagramm des Factory-Methodenmusters können Sie ersehen, dass das Factory-Methodenmuster vier hat Elemente:

• Factory-Schnittstelle. Die Factory-Schnittstelle ist der Kern des Factory-Methodenmusters, das direkt mit dem Aufrufer interagiert, um Produkte bereitzustellen. In der tatsächlichen Programmierung wird manchmal eine abstrakte Klasse als Schnittstelle für die Interaktion mit dem Aufrufer verwendet, was im Wesentlichen dasselbe ist.

• Werksimplementierung. Bei der Programmierung bestimmt die Factory-Implementierung, wie Produkte instanziiert werden. Wie viele Produkte benötigt werden, hängt davon ab, wie viele spezifische Factory-Implementierungen benötigt werden.

• Produktschnittstelle. Der Hauptzweck der Produktschnittstelle besteht darin, die Spezifikationen des Produkts zu definieren, und alle Produktimplementierungen müssen den durch die Produktschnittstelle definierten Spezifikationen folgen. Die Produktschnittstelle ist das, was dem Anrufer am meisten am Herzen liegt. Die Qualität der Produktschnittstellendefinition bestimmt direkt die Stabilität des Codes des Anrufers. Ebenso können Produktschnittstellen auch durch abstrakte Klassen ersetzt werden. Achten Sie jedoch darauf, das Liskov-Substitutionsprinzip nicht zu verletzen.

• Produktimplementierung. Die spezifische Klasse, die die Produktschnittstelle implementiert, bestimmt das spezifische Verhalten des Produkts im Client.
  

Das oben erwähnte einfache Factory-Muster ist dem Factory-Methodenmuster sehr ähnlich. Der Unterschied besteht darin, dass die einfache Factory nur drei Elemente hat und keine Factory-Schnittstelle hat Die Art und Weise, wie das Produkt erhalten wird, ist statisch. Da es keine Factory-Schnittstelle gibt, ist die Skalierbarkeit der Factory-Implementierung etwas schwächer. Sie kann als vereinfachte Version des Factory-Methodenmusters betrachtet werden.

Anwendbare Szenarien:

Unabhängig davon, ob es sich um ein einfaches Fabrikmuster, ein Fabrikmethodenmuster oder ein abstraktes Fabrikmuster handelt, haben sie ähnliche Eigenschaften Auch die anwendbaren Szenarien sind ähnlich.

Als Klassenerstellungsmuster kann das Factory-Methodenmuster zunächst überall dort eingesetzt werden, wo komplexe Objekte generiert werden müssen. Zu beachten ist, dass komplexe Objekte für die Verwendung des Factory-Musters geeignet sind, während einfache Objekte, insbesondere solche, die nur durch Neu erstellt werden können, das Factory-Muster nicht verwenden müssen. Wenn Sie das Factory-Muster verwenden, müssen Sie eine Factory-Klasse einführen, was die Komplexität des Systems erhöht.

Zweitens ist der Fabrikmodus ein typischer Entkopplungsmodus, und das Dimit-Gesetz ist im Fabrikmodus besonders offensichtlich. Wenn der Anrufer das Produkt selbst zusammenstellt und Abhängigkeiten hinzufügen muss, kann er die Verwendung des Factory-Musters in Betracht ziehen. Reduziert die Kopplung zwischen Objekten erheblich.

Drittens: Da das Fabrikmuster auf abstrakter Architektur basiert, übergibt es die Aufgabe der Instanziierung von Produkten an die Implementierungsklasse und weist eine bessere Skalierbarkeit auf. Mit anderen Worten: Wenn das System eine bessere Skalierbarkeit benötigt, kann das Fabrikmodell in Betracht gezogen werden und verschiedene Produkte mithilfe unterschiedlicher Implementierungsfabriken zusammengestellt werden.                                                                                                              

       要说明工厂模式的优点，可能没有比组装汽车更合适的例子了。场景是这样的：汽车由发动机、轮、底盘组成，现在需要组装一辆车交给调用者。假如不使用工厂模式，代码如下：

class Engine { 
  public void getStyle(){ 
    System.out.println("这是汽车的发动机"); 
  } 
} 
class Underpan { 
  public void getStyle(){ 
    System.out.println("这是汽车的底盘"); 
  } 
} 
class Wheel { 
  public void getStyle(){ 
    System.out.println("这是汽车的轮胎"); 
  } 
} 
public class Client { 
  public static void main(String[] args) { 
    Engine engine = new Engine(); 
    Underpan underpan = new Underpan(); 
    Wheel wheel = new Wheel(); 
    ICar car = new Car(underpan, wheel, engine); 
    car.show(); 
  } 
}

        可以看到，调用者为了组装汽车还需要另外实例化发动机、底盘和轮胎，而这些汽车的组件是与调用者无关的，严重违反了迪米特法则，耦合度太高。并且非常不利于扩展。另外，本例中发动机、底盘和轮胎还是比较具体的，在实际应用中，可能这些产品的组件也都是抽象的，调用者根本不知道怎样组装产品。假如使用工厂方法的话，整个架构就显得清晰了许多。

interface IFactory { 
  public ICar createCar(); 
} 
class Factory implements IFactory { 
  public ICar createCar() { 
    Engine engine = new Engine(); 
    Underpan underpan = new Underpan(); 
    Wheel wheel = new Wheel(); 
    ICar car = new Car(underpan, wheel, engine); 
    return car; 
  } 
} 
public class Client { 
  public static void main(String[] args) { 
    IFactory factory = new Factory(); 
    ICar car = factory.createCar(); 
    car.show(); 
  } 
}

        使用工厂方法后，调用端的耦合度大大降低了。并且对于工厂来说，是可以扩展的，以后如果想组装其他的汽车，只需要再增加一个工厂类的实现就可以。无论是灵活性还是稳定性都得到了极大的提高。

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