Java-Entwurfsmuster – Fabrikmuster

1. Das Factory-Muster stellt hauptsächlich eine Übergangsschnittstelle zum Erstellen von Objekten bereit, um den spezifischen Prozess der Objekterstellung abzuschirmen und zu isolieren, um den Zweck der Verbesserung der Flexibilität zu erreichen.

Factory-Muster sind in „Java und Muster“ in drei Kategorien unterteilt:
1) Einfaches Factory-Muster (Simple Factory): Nicht förderlich für die Erstellung eines Serie von Produkten;

2) Fabrikmethode: auch als polymorphe Fabrik bekannt; neue Produkte;
Diese drei Modi werden schrittweise von oben nach unten abstrahiert und sind allgemeiner.
GOF hat das Fabrikmuster im Buch „Design Patterns“ in zwei Kategorien unterteilt: Fabrikmethodenmuster (Fabrikmethode) und abstraktes Fabrikmuster (Abstrakte Fabrik). Stellen Sie sich das Muster „Simple Factory“ als Sonderfall des Musters „Factory Method“ vor, und beide werden derselben Kategorie zugeordnet.


2. Einfaches Fabrikmuster

Einfaches Fabrikmuster wird auch als statisches Fabrikmethodenmuster bezeichnet. Aus der Umbenennung ist ersichtlich, dass dieser Modus sehr einfach sein muss. Sein Zweck ist einfach: eine Schnittstelle zum Erstellen von Objekten zu definieren.

Im einfachen Fabrikmuster steht eine Fabrikklasse im Mittelpunkt des Aufrufs zur Produktklasseninstanziierung. Sie bestimmt, welche Produktklasse instanziiert werden soll, genau wie ein Verkehrspolizist, der vor vorbeifahrenden Fahrzeugen steht Im Fluss ist es dasselbe, als würde man entscheiden, in welche Richtung die Fahrzeuge strömen sollen.

Werfen wir zunächst einen Blick auf seine Zusammensetzung:

1) Fabrikrolle: Dies ist der Kern dieses Modells und enthält bestimmte Geschäftslogik und Beurteilungslogik. In Java wird es oft durch eine konkrete Klasse implementiert.

2) Abstrakte Produktrolle: Es handelt sich im Allgemeinen um die übergeordnete Klasse, die von einem bestimmten Produkt oder der implementierten Schnittstelle geerbt wird. Es wird in Java über eine Schnittstelle oder eine abstrakte Klasse implementiert.

3) Spezifische Produktrolle: Das von der Factory-Klasse erstellte Objekt ist eine Instanz dieser Rolle. Implementiert durch eine konkrete Klasse in Java.

3. Factory-Methodenmuster

Das Factory-Methodenmuster ist eine weitere Abstraktion und Förderung des einfachen Fabrikmethodenmusters. Beim Factory-Methodenmuster bestimmt nicht mehr nur eine Fabrikklasse Produktklasse Sollte instanziiert werden, wird diese Entscheidung der abstrakten Factory-Unterklasse überlassen.

Werfen wir einen Blick auf seine Zusammensetzung:

1) Abstrakte Fabrikrolle: Dies ist der Kern des Fabrikmethodenmusters und hat nichts mit der Anwendung zu tun. Es handelt sich um die Schnittstelle, die eine bestimmte Factory-Rolle implementieren muss, oder um die übergeordnete Klasse, die geerbt werden muss. In Java wird es durch abstrakte Klassen oder Schnittstellen implementiert.

2) Spezifische Factory-Rolle: Sie enthält Code, der sich auf eine bestimmte Geschäftslogik bezieht. Wird von einer Anwendung aufgerufen, um ein Objekt zu erstellen, das einem bestimmten Produkt entspricht.

3) Abstrakte Produktrolle: Es handelt sich um die übergeordnete Klasse, die von einem bestimmten Produkt oder der implementierten Schnittstelle geerbt wird. In Java müssen im Allgemeinen abstrakte Klassen oder Schnittstellen implementiert werden.

4) Spezifische Produktrolle: Das von der spezifischen Factory-Rolle erstellte Objekt ist eine Instanz dieser Rolle. Es wird durch bestimmte Klassen in Java implementiert.
Das Fabrikmethodenmuster verwendet mehrere von der abstrakten Fabrikrolle geerbte Unterklassen, um die „Gottklasse“ im einfachen Fabrikmuster zu ersetzen. Wie oben erwähnt, wird dadurch der Druck auf das Objekt geteilt, und dies macht die Struktur flexibel – wenn ein neues Produkt (d. h. das Auto des Emporkömmlings) produziert wird, sofern es gemäß der abstrakten Produktrolle und der abstrakten Fabrikrolle bereitgestellt wird generiert, die dann von Kunden genutzt werden können, ohne dass vorhandener Code geändert werden muss. Es ist ersichtlich, dass auch die Struktur der Fabrikrolle dem Öffnungs- und Schließprinzip entspricht!

Code:

//抽象产品角色
public interface Moveable {
    void run();
}
//具体产品角色
public class Plane implements Moveable {
    @Override
    public void run() {
        System.out.println("plane....");
    }
}

public class Broom implements Moveable {
    @Override
    public void run() {
        System.out.println("broom.....");
    }
}

//抽象工厂
public abstract class VehicleFactory {
    abstract Moveable create();
}
//具体工厂
public class PlaneFactory extends VehicleFactory{
    public Moveable create() {
        return new Plane();
    }
}
public class BroomFactory extends VehicleFactory{
    public Moveable create() {
        return new Broom();
    }
}
//测试类
public class Test {
    public static void main(String[] args) {
        VehicleFactory factory = new BroomFactory();
        Moveable m = factory.create();
        m.run();
    }
}

Es ist ersichtlich, dass durch das Hinzufügen von Factory-Methoden die Anzahl der Objekte verdoppelt wurde. Wenn es viele Produkttypen gibt, wird eine große Anzahl entsprechender Fabrikobjekte angezeigt, was nicht das ist, was wir wollen. Denn wenn sich diese Situation nicht vermeiden lässt, können Sie eine Kombination aus dem einfachen Factory-Muster und dem Factory-Methodenmuster in Betracht ziehen, um Factory-Klassen zu reduzieren: Das heißt, Sie verwenden eine einfache Factory für ähnliche Typen im Produktbaum (normalerweise Brüder unter den Blättern von). der Baum) Muster zu erreichen.

4. Vergleich zwischen einfachen Factory- und Factory-Methodenmustern

Der Unterschied in der Definition zwischen Factory-Methodenmustern und einfachen Factory-Mustern ist offensichtlich. Der Kern des Factory-Methodenmusters ist eine abstrakte Factory-Klasse, im Gegensatz zum einfachen Factory-Muster, bei dem der Kern auf einer realen Klasse liegt. Das Factory-Methodenmuster ermöglicht es vielen realen Factory-Klassen, von der abstrakten Factory-Klasse zu erben, was tatsächlich zu einer Synthese mehrerer einfacher Factory-Muster werden kann, wodurch das einfache Factory-Muster populär wird.
Andererseits ist das einfache Fabrikmuster vom Fabrikmethodenmuster degeneriert. Stellen Sie sich vor, wenn wir sehr sicher sind, dass ein System nur eine echte Factory-Klasse benötigt, dann könnten wir die abstrakte Factory-Klasse genauso gut mit der realen Factory-Klasse zusammenführen. Und auf diese Weise werden wir zum einfachen Fabrikmodell degradieren.

5. Abstraktes Fabrikmuster

Code:

//抽象工厂类
public abstract class AbstractFactory {
    public abstract Vehicle createVehicle();
    public abstract Weapon createWeapon();
    public abstract Food createFood();
}
//具体工厂类，其中Food,Vehicle，Weapon是抽象类，
public class DefaultFactory extends AbstractFactory{
    @Override
    public Food createFood() {
        return new Apple();
    }
    @Override
    public Vehicle createVehicle() {
        return new Car();
    }
    @Override
    public Weapon createWeapon() {
        return new AK47();
    }
}
//测试类
public class Test {
    public static void main(String[] args) {
        AbstractFactory f = new DefaultFactory();
        Vehicle v = f.createVehicle();
        v.run();
        Weapon w = f.createWeapon();
        w.shoot();
        Food a = f.createFood();
        a.printName();
    }
}

Im Abstrakten Fabrikmuster kann das abstrakte Produkt (AbstractProduct) eines oder mehrere sein und somit ein oder mehrere bilden Mehrere Produktfamilien. Bei nur einer Produktfamilie degeneriert das abstrakte Fabrikmuster tatsächlich zum Fabrikmethodenmuster.

6. Zusammenfassung.

(1) Das einfache Factory-Muster verwendet eine bestimmte Klasse, um Instanzen anderer Klassen zu erstellen. Die übergeordnete Klasse ist dieselbe und die übergeordnete Klasse ist spezifisch.
(2) Das Factory-Methodenmuster verfügt über eine abstrakte übergeordnete Klasse, die eine öffentliche Schnittstelle definiert, und die Unterklasse ist für die Generierung bestimmter Objekte verantwortlich. Der Zweck besteht darin, die Instanziierung der Klasse zur Unterklasse zu verzögern.
(3) Das abstrakte Factory-Muster bietet eine Schnittstelle zum Erstellen einer Reihe verwandter oder voneinander abhängiger Objekte, ohne deren spezifische Klassen anzugeben. Es zielt auf hierarchische Strukturen mit mehreren Produkten ab. Das Factory-Methodenmuster zielt auf die hierarchische Struktur eines Produkts ab.