So implementieren Sie das Fabrikmuster von Java-Entwurfsmustern

Die Details sind wie folgt:

Das Factory-Muster stellt hauptsächlich eine Übergangsschnittstelle zum Erstellen von Objekten bereit, um den spezifischen Prozess des Erstellens von Objekten abzuschirmen und zu isolieren, um den Zweck der Verbesserung der Flexibilität zu erreichen# 🎜🎜##🎜🎜 #Fabrikmuster sind in drei Kategorien unterteilt:

1) Einfaches Fabrikmuster (einfache Fabrik): nicht förderlich für die Herstellung einer Produktserie;

2) Fabrikmethode Muster (Factory-Methode): auch bekannt als Polymorphic Factory;

3) Abstract Factory-Muster (Abstract Factory): auch bekannt als Toolbox, generiert Produktfamilien, ist aber nicht förderlich für die Generierung neuer Produkte; 🎜#
一, Einfaches Factory-Muster

Einfaches Factory-Muster wird auch als statisches Factory-Methodenmuster 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 Factory-Muster steht eine Factory-Klasse im Mittelpunkt des Produktklassen-Instanziierungsaufrufs. Sie bestimmt, welche Produktklasse instanziiert werden soll, genau wie ein Verkehrspolizist, der im Strom vorbeifahrender Fahrzeuge steht und beschließt, sie zuzulassen fahren. Fahrzeuge in dieser Richtung fließen in die gleiche Richtung. 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: Im Allgemeinen handelt es sich 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.

2. Factory-Methodenmuster

Das Factory-Methodenmuster ist eine weitere Abstraktion und Weiterentwicklung des einfachen Factory-Methodenmusters Es liegt nicht mehr nur an einer Fabrikklasse, zu entscheiden, welche Produktklasse instanziiert werden soll, und diese Entscheidung wird den Unterklassen der abstrakten Fabrik überlassen. Werfen wir einen Blick auf seine Zusammensetzung: 1) Abstrakte Fabrikrolle: Dies ist der Kern des Fabrikmethodenmusters, das nichts mit der Anwendung zu tun hat. 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 die Struktur flexibler – wenn ein neues Produkt (d. h. das aufstrebende Auto) produziert wird, sofern es gemäß der abstrakten Produktrolle und der abstrakten Fabrikrolle bereitgestellt wird Es werden Verträge 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!

Der Code lautet wie folgt:

//抽象产品角色
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();
  }
}

3. Abstraktes Fabrikmuster

Der Code lautet wie folgt# 🎜🎜#

//抽象工厂类
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 es ein oder mehrere abstrakte Produkte (AbstractProduct) geben und so eine oder mehrere Produktfamilien (Product Family) bilden. Bei nur einer Produktfamilie degeneriert das abstrakte Fabrikmuster tatsächlich zum Fabrikmethodenmuster.

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