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“
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.
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
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.
4. Implementierung des Mustercodes der Fabrikmethode
Die Produkte sind: Coca-Cola, Pepsi-Cola, zuckerfreie Cola
Abstrakte Fabrik: Koksfabrik (kann als Hauptfabrik verstanden werden)
Pepsi-Cola-Fabrik: 
Pepsi-Cola erzeugen
Zuckerfreie Koksfabrik: Zuckerfrei erzeugen Cola
/**
* 提供了产品的接口
*/public interface Cola {
//生产可乐的方法
public void cola();}Nach dem Login kopieren
Cola Abstract Factory:
/**
* 可乐抽象工厂(可以理解成可乐总厂，旗下还有很多分厂)
*/public interface ColaFactory {
public Cola newCola();}/**
* 产品名称：可乐可乐，实现了产品的接口
*/public class CocaCola implements Cola{
@Override
public void cola() {
System.out.println("开始生产可口可乐");
}}/**
*
* 产品名称：百事可乐，实现了产品的接口
*/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("开始生产无糖可乐");
}}Nach dem Login kopieren
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: Die Fabrik, die zuckerfreie Cola herstellt: /**
*
* 具体工厂2：百事可乐工厂
*/public class PepsiColaFactory implements ColaFactory{
@Override
public Cola newCola() {
System.out.println("我是可乐工厂下面的百事可乐工厂");
return new PepsiCola();
}}Nach dem Login kopieren
/*
* 具体工厂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)
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());
}
}}我是可乐工厂下面的无糖可乐工厂 开始生产无糖可乐
如果传入CocaColaFactory：
我是可乐工厂下面的可口可乐工厂 开始生产可口可乐
这就是工厂方法模式，和简单工厂模式有所不同，在这个模式内有一个抽象工厂接口，也就是你需要增加新产品后，不需要在原本的工厂内去修改代码，而是直接新建一个工厂，去实现抽象工厂即可，也是符合了开闭原则。
当然缺点也就是工厂多了，管理变得复杂，也增加了系统的抽象性和理解难度，而且抽象产品只能生产一种产品，但是此弊端可使用抽象工厂模式解决（抽象工厂模式在下一篇文章）
推荐学习：《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!
