Factory-Muster
1. Einfache Factory
Verstehen
Factory-Klassen im einfachen Factory-Muster verwenden im Allgemeinen statische Methoden und geben unterschiedliche Werte basierend auf den Parametern zurück, die sie haben Objektinstanz erhalten.
Es kann nicht erweitert werden, ohne den Code zu ändern.
Beispiel
Produktschnittstelle
//Produktschnittstelle
öffentliche Schnittstelle ProductI {
public void productName();
Produktentitätsklasse
öffentliche Klasse ProductA implementiert ProductI {
@Override
public void productName() {
System.out.println("product A");
}
}
öffentliche Klasse ProductB implementiert ProductI {
@Override
public void productName() {
System.out.println("product B"); >
// Einfaches Factory-Muster
public class Factory {
public ProductI create(String productName) {
switch (productName) {
case „A“:
return new ProductA( );
case „B“:
return new ProductB();
return null; void main(String[] args) {
Factory Factory = new Factory();
ProductI ProductA = Factory.create("A"); 🎜> ProductI ProduktB = Factory.create("B");
ProduktB.Produktname();
}
}
Ausgabe
Produkt A
Produkt B
Factory-Methode
Verstehen
Die Factory-Methode stellt für jedes Produkt eine Factory-Klasse bereit. Verschiedene Produktinstanzen werden über verschiedene Factory-Instanzen erstellt.
In der gleichen hierarchischen Struktur wird jedes Produkt unterstützt.
Beispiel
Die Produktschnittstelle, die Produktentitätsklasse und die einfache Fabrik sind gleich.
Factory-Schnittstelle
public interface FactoryI {
// Der Zweck der Fabrik besteht darin, Produkte zu produzieren
public ProductI create();
Factory-Entität Klasse
öffentliche Klasse FactoryA implementiert FactoryI {
@Override
public ProductI create() {
return new ProductA();
}
}
öffentliche Klasse FactoryB implementiert FactoryI {
@Override
public ProductI create() {
return new ProductB();
}
Testklasse
// Factory-Methodenmuster
public class Client {
public static void main(String[] args) {
FactoryIfactoryA = new FactoryA();
productA.productName () ;
//
FactoryI FactoryB();
Produkt A
Produkt B
Abstract Factory
Verstehen
Abstract Factory beschäftigt sich mit dem Konzept der Produktfamilie. Beispielsweise möchte möglicherweise jedes Automobilunternehmen gleichzeitig Autos, Lastwagen und Busse produzieren, sodass jede Fabrik über eine Methode zur Herstellung von Autos, Lastwagen und Bussen verfügen muss.
Als Reaktion auf das Konzept der Produktfamilie ist es einfach, neue Produktlinien hinzuzufügen, aber es ist unmöglich, neue Produkte hinzuzufügen.
Der Unterschied zu Fabrikmethoden besteht darin, dass abstrakte Fabriken häufig über mehrere Methoden verfügen, mit denen mehrere Produkte hergestellt werden können, dh Produktcluster.
Beispiel
Abstract Factory Class
// Wire Factory Pattern
public interface AbstractFactory {
public ProductAI createProductA();
public ProductBI createProductB(); 🎜>}
Factory-Entitätsklasse
öffentliche Klasse Factory1 implementiert AbstractFactory {
@Override
public ProductAI createProductA() {
return new ProductA1();
}
@Override
public ProductBI createProductB() {
return new ProductB1();
}
}
öffentliche Klasse Factory2 implementiert AbstractFactory {
@Override
public ProductAI createProductA() {
return new ProductA2();
}
@Override
public ProductBI createProductB() {
return new ProductB2();
}
}
产品接口
//产品接口
public interface ProductBI {
public void productName();
}
//产品接口
public interface ProductAI {
public void productName();
}
产品实体类
public class ProductA1 implementiert ProductAI {
@Override
public void productName() {
System.out.println("product A1") ;
}
}
更多Java设计模式之工厂模式(三种)相关文章请关注PHP中文网!