So implementieren Sie das Java-Factory-Methodenmuster

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 besteht darin, die Produktklasse in zu konvertieren. Der Instanziierungsvorgang wird auf die Factory-Unterklasse verschoben, dh 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 erbt auch die Vorteile des einfachen Factory-Musters.

Beispiel:

In der Coca-Cola-Fabrik im Artikel über einfache Fabrikmuster, da es nur eine Fabrikklasse gibt, muss jedes Produkt dies tun In dieser Klasse befinden sich Modifikatoren und Anpassungen. Das Muster der Fabrikmethode besteht darin, mehrere Fabriken zu haben. Jede Fabrik produziert ein Produkt. Wenn wir neue Produkte hinzufügen müssen, können wir direkt eine neue Fabrik erstellen, ohne dass neue hinzugefügt werden müssen Gehen Sie und ändern Sie es so, dass es dem Öffnungs- und Schließprinzip entspricht.

2. Vor- und Nachteile des Factory-Methodenmusters

Vorteile:

• #🎜 🎜# Benutzer müssen nur den Namen der jeweiligen Fabrik kennen, um das gewünschte Produkt zu erhalten, und müssen nicht den spezifischen Erstellungsprozess des Produkts kennen. Schreiben Sie eine weitere entsprechende Fabrikklasse

  #🎜🎜 #

  Ein typisches Entkopplungs-Framework. Nach dem Demeter-Gesetz, dem Abhängigkeitsinversionsprinzip und dem Richter-Substitutionsprinzip müssen High-Level-Module nur auf die abstrakte Klasse des Produkts zugreifen, ohne andere Implementierungsklassen zu berücksichtigen:

• #🎜🎜 #

  Es ist leicht, zu viele Klassen zu haben, was die Komplexität erhöht

• erhöhen Es verringert die Abstraktions- und Verständnisschwierigkeit des Systems
# 🎜🎜#

Abstrakte Produkte können nur ein Produkt produzieren, indem Abstraktes Fabrikmuster(Abstraktes Fabrikmuster im nächsten Artikel)

verwendet wird.

• 3. Aufbau und Umsetzung des Musters

Der Aufbau besteht aus folgenden vier Teilen: #🎜🎜 #

• # 🎜🎜#Abstract Factory: Stellt eine Schnittstelle zum Erstellen von Produkten bereit, über die der Aufrufer auf die Factory-Methode newProduct() der jeweiligen Factory zugreift, um Produkte zu erstellen.

  #🎜🎜 #
• ConcreteFactory: Hauptsächlich implementiert die abstrakten Methoden in der abstrakten Fabrik und schließt die Erstellung spezifischer Produkte ab
  Abstraktes Produkt (Produkt): Definiert die Spezifikation des Produkts und beschreibt die Hauptmerkmale und -funktionen der zu erstellenden Produktfabrik besteht eine Eins-zu-eins-Entsprechung mit der spezifischen Fabrik

Strukturdiagramm:

#🎜🎜 #

#🎜 🎜#

• 4. Implementierung des Factory-Methodenmustercodes

Oder die Coca-Cola-Fabrik im vorherigen Artikel als Beispiel:
• #🎜 🎜# Zu den Produkten gehören: Coca-Cola, Pepsi-Cola, zuckerfreie Cola
  Im einfachen Fabrikmodus gibt es nur eine Cola-Fabrik, die drei Produkte herstellen kann Es können mehrere Fabriken sein, um entsprechende Produkte zu erzeugen:
# 🎜🎜#
• Abstrakte Fabrik:

  Coke Factory (kann als Hauptfabrik verstanden werden)

Pepsi-Cola Fabrik:
• Pepsi-Cola generieren
  Coca-Cola-Fabrik:
Coca-Cola generieren

Zuckerfreie Cola-Fabrik: Generieren Zuckerfreie Cola

Methode zur Herstellung von Cola: # 🎜🎜#

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

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

Cola-Abstraktfabrik:

/**
 * 可乐抽象工厂(可以理解成可乐总厂，旗下还有很多分厂)
 */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("开始生产百事可乐");
    }}

Sugar- kostenlose Cola:

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

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

Drei Produkte entsprechen drei Fabriken:
Die Fabrik, die Coca-Cola produziert:

/**
 *
 * 具体工厂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 sind es:

Eine Methode zur Herstellung von Cola

#🎜 🎜#Eine Koksfabrik (unten gibt es mehrere kleine Fabriken)#🎜 🎜#
Drei Methoden zur Herstellung von drei Arten von Cola (Implementierung der Coca-Cola-Schnittstelle)

#🎜🎜 #

Drei Cola-Fabriken (produzieren drei Arten von Cola und implementieren die Cola-Factory-Schnittstelle) Ich brauche jetzt Pepsi, ich komme in der Pepsi-Fabrik in af vorbei:

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 in

CocaColaFactory vorbeigehe: #🎜🎜 #

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

Das obige ist der detaillierte Inhalt vonSo implementieren Sie das Java-Factory-Methodenmuster. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!