設計模式 （四）抽象工廠模式
阿新 • • 發佈：2018-11-13
在有道雲筆記上寫的，抽象工廠模式
抽象工廠模式：提供一個建立一系列相關或相互依賴的物件的介面，而無需指定他們具體的類
抽象工廠模式的優點：易於交換產品系列，在一個應用中只需要在初始化的時候出現一次。它讓具體的建立例項與客戶端相分離，不會出現在客戶端的程式碼中
缺點：如果要增加一個產品的話，需要改動的類很多
這是我寫的三個例子：每個part下面一個例子
part01:抽象工廠模式
抽象工廠模式的類圖如下：（選自大話設計模式，ps我的所有的設計模式的圖片都來自這裡）
以下是程式碼
public abstract class AbstractProductA { public AbstractProductA() { } } public abstract class AbstractProductB { public AbstractProductB() { } } public class ProductA1 extends AbstractProductA { public ProductA1() { } } public class ProductA2 extends AbstractProductA { public ProductA2() { } } public class ProductB1 extends AbstractProductB { public ProductB1() { } } public class ProductB2 extends AbstractProductB { public ProductB2() { } } public abstract class AbstractFactory { public abstract AbstractProductA createProductA(); public abstract AbstractProductB createProductB(); } public class ConcreteFactory1 extends AbstractFactory { @Override public AbstractProductA createProductA() { System.out.println("工廠一生產產品A1"); return new ProductA1(); } @Override public AbstractProductB createProductB() { System.out.println("工廠一生產產品B1"); return new ProductB1(); } } public class ConcreteFactory2 extends AbstractFactory { @Override public AbstractProductA createProductA() { System.out.println("工廠二生產產品A2"); return new ProductA2(); } @Override public AbstractProductB createProductB() { System.out.println("工廠二生產產品B2"); return new ProductB2(); } } public class Client { public static void main(String[] args) { AbstractFactory af=new ConcreteFactory2(); af.createProductA(); af.createProductB(); } }
加入我現在要加一個產品C，需要改變的類由AbstractProduct,ConctreteFactory1,,ConctreteFactory2,這是很麻煩的，所以不如簡單工廠模式來的痛快
part01:針對以上問題寫的簡單工廠模式
public abstract class AbstractProductA { public AbstractProductA() { } } public abstract class AbstractProductB { public AbstractProductB() { } } public class ProductA1 extends AbstractProductA { public ProductA1() { } } public class ProductA2 extends AbstractProductA { public ProductA2() { } } public class ProductB1 extends AbstractProductB { public ProductB1() { } } public class ProductB2 extends AbstractProductB { public ProductB2() { } } public class SimpleFactory { public SimpleFactory() { } public AbstractProductA createProductA(String h){ AbstractProductA a; switch (h) { case "A1": a=new ProductA1(); System.out.println("生產A1"); break; case "A2": a=new ProductA2(); System.out.println("生產A2"); break; default: a=null; break; } return a; } public AbstractProductB createProdutB(String h){ AbstractProductB b; switch (h) { case "B1": b=new ProductB1(); System.out.println("生產B1"); break; case "B2": b=new ProductB2(); System.out.println("生產B2"); break; default: b=null; break; } return b; } } public class Client { public static void main(String[] args) { SimpleFactory simpleFactory=new SimpleFactory(); simpleFactory.createProductA("A1"); simpleFactory.createProdutB("B2"); } }
但是正如你知道的，簡單工廠模式違背了開放-封閉原則，所以part03是用反射解決這個問題的
public abstract class AbstractProductA {
public AbstractProductA() {
}
}
public abstract class AbstractProductB {
public AbstractProductB() {
}
}
public class ProductA1 extends AbstractProductA {
public ProductA1() {
}
}
public class ProductA2 extends AbstractProductA {
public ProductA2() {
}
}
public class ProductB1 extends AbstractProductB {
public ProductB1() {
}
}
public class ProductB2 extends AbstractProductB {
public ProductB2() {
}
}
public class Factory {
public Class createProductA(String h) throws ClassNotFoundException {
if(h=="A1"||h=="A2") {
Class a = Class.forName("AbstractFactory.part03.Product"+h);
System.out.println("生產產品"+h);
return a;
}
else
{
return null;
}
}
public Class createProductB(String h) throws ClassNotFoundException {
if(h=="B1"||h=="B2") {
Class b = Class.forName( "AbstractFactory.part03.Product"+h);
System.out.println("生產產品"+h);
return b;
}else
{
return null;
}
}
}
public class Client {
public static void main(String[] args) throws ClassNotFoundException {
Factory f=new Factory();
f.createProductA("A1");
f.createProductA("A2");
f.createProductB("B1");
f.createProductB("B2");
}
}這個是最有效的方法啦