Das Fabrikmuster kann verwendet werden, um den Erstellungsprozess und die Verwendung von Objekten zu trennen (dh zu entkoppeln) und so die Kapselung des Objekterstellungsprozesses zu fördern.
Wenn Sie die Beispiele 1 und 4 im vorherigen Artikel „Hinweise zum Erlernen von Java-Entwurfsmustern für Anfänger – Fabrikmuster“ durchgehen , haben Sie möglicherweise die folgenden Fragen:
Warum eine abstrakte Produktklasse?
Warum gibt die Factory-Methode einen abstrakten Produktklassentyp zurück?
Warum wird das Produktklassenobjekt beim Aufruf durch den Client auch über die abstrakte Produktklasse definiert?
Dies ist der Polymorphismus der Produktklasse im Fabrikmuster .
Da die spezifische Produktklasse von der abstrakten Produktklasse erbt (oder implementiert), muss der Client den tatsächlichen Typ des spezifischen Produkts nicht kennen und kann trotzdem das gewünschte Produkt erhalten.
Dieser Polymorphismus fördert den Kapselungseffekt des Factory-Musters. Die Factory-Klasse kapselt vollständig die Details darüber, welches Produkt erstellt wird und wie das Produktobjekt erstellt wird.
Polymorphismus anhand der realen Welt verstehen:
Kunde A wollte ursprünglich einen Audi A6 kaufen, doch der Hersteller produzierte zufällig ein neues Modell des Audi A8. Der Audi A6 wurde eingestellt und der Preis blieb in etwa gleich. Also änderte Kunde A die Bestellung und kaufte einen Audi A8.
Basierend auf Beispiel 1 müssen wir dann nur noch eine neue spezifische Produktklasse AudiA8Car hinzufügen und dann die Fabrikklasse CarFactory ändern.
Beispiel 5:
Audi A8 (spezifische Produktrolle):
Eine neue spezifische Produktkategorie wurde hinzugefügt: Neuwagen von FAW-Volkswagen.
/*
* 奥迪A8，是一汽大众生产的一款汽车 （具体产品类）
*/
public class AudiA8Car extends Car {
public AudiA8Car(){
this.name = "奥迪A8";
}
public String toString(){
return "一辆"+ this.name;
}
}
FAW-Volkswagen (Werksrolle):
Die statische Factory-Methode ManufactureCar() wurde geändert. Sie gab ursprünglich das Objekt AudiA6Car zurück , jetzt aber das Objekt AudiA8Car .
/*
* 生产汽车的工厂，一汽大众 （工厂类）
*/
public class CarFactory {
/*
* 生产汽车（通过一个静态方法来得到一辆汽车的对象）
*/
public static Car manufactureCar(){
// 奥迪A6停产了
// return new AudiA6Car();
// 新款汽车奥迪A8
return new AudiA8Car();
}
}
Auto (abstrakte Produktrolle):
Wie Beispiel 1, es wurden keine Änderungen vorgenommen.
/*
* 奥迪A6，是一汽大众生产的一款汽车 （具体产品类）
*/
public class AudiA6Car extends Car {
public AudiA6Car(){
this.name = "奥迪A6";
}
public String toString(){
return "一辆"+ this.name;
}
}
Kunde A (Kunde), der diesen Audi A6 gekauft hat:
Auch das Gleiche wie Beispiel 1, ohne Änderungen.
/*
* 购买汽车的顾客A(客户端)
*/
public class CustomerA {
public static void main(String[] args){
// 通过汽车工厂来制造出了一辆汽车
Car myCar = CarFactory.manufactureCar();
System.out.println("一辆汽车被造好，并且出厂了。");
// 顾客得到了一辆汽车，十分的高兴
System.out.println("我终于买了"+myCar+"。真是太好了！");
}
}
Operationsergebnis:
一辆汽车被造好，并且出厂了。
我终于买了一辆奥迪A8。真是太好了！
Anhand der obigen Laufergebnisse können Sie die Vorteile dieses Polymorphismus erkennen:
Der Kapselungseffekt wird verbessert und der Kunde kann die Änderung der Anforderungen realisieren, ohne Änderungen vorzunehmen.
Allgemein,
Das Fabrikmuster trennt die Erstellung und Verwendung von Objekten durch Entkopplung und Polymorphismus, kapselt den komplexen Objekterstellungsprozess und vereinheitlicht die Verwendung von Objekten.
Es erleichtert die Wartung und Änderung des Codes, erleichtert die Anpassung des Codes an geänderte Anforderungen und verringert die Auswirkungen dieser Änderungen auf das System.