淺析 抽象工廠、Factory 方法、簡單(靜態)工廠

標籤：原廠模式   抽象工廠   Factory 方法   設計模式   繼承   

----簡單工廠(也叫靜態原廠模式)：一個抽象產品抽象出多個具體產品類，一個具體工廠類
代碼：

//抽象產品角色public interface Car{      public void drive();}//具體產品角色public class Benz implements Car{      public void drive() {         System.out.println("Driving Benz ");      }}public class Bmw implements Car{      public void drive() {       System.out.println("Driving Bmw ");      }}//工廠類角色public class Driver{            //Factory 方法.注意 傳回型別為抽象產品角色             public static Car driverCar(String s)throws Exception{                   //判斷邏輯，返回具體的產品角色給Client                   if(s.equalsIgnoreCase("Benz"))                        return new Benz();                   else if(s.equalsIgnoreCase("Bmw"))                            return new Bmw();                                 ......                              else throw new Exception();             。。。//歡迎暴發戶出場......public class Magnate{             public static void main(String[] args){                        try{                              //告訴司機我今天坐平治                                                      Car car = Driver.driverCar("benz");                              //下命令：開車                                                             car.drive();                        。。。

----Factory 方法    Factory 方法：一抽象產品類派生出多個具體產品類；一抽象工廠類派生出多個具體工廠類；每個具體工廠類只能建立一個具體產品類的執行個體。

    即定義一個建立對象的介面（即抽象工廠類），讓其子類（具體工廠類）決定執行個體化哪一個類（具體產品類）。“一對一”的關係。

（圖中的實線表示繼承錯了，應該是虛線，表示實現）

Factory 方法：

public interface Product{       }public interface Creator{       public Product factory();}public class ConcreteProduct1 implements Product{       public ConcreteProduct1()       {              System.out.println("ConcreteProduct1被建立");       }}public class ConcreteProduct2 implements Product{       public ConcreteProduct2()       {              System.out.println("ConcreteProduct2被建立");       } }public class ConcreteCreator1 implements Creator{       public Product factory()       {              return new ConcreteProduct1();       }}public class ConcreteCreator2 implements Creator{       public Product factory()       {              return new ConcreteProduct2();       }} public class Client{       private static Creator creator1, creator2;       private static Product prod1, prod2;       public static void main(String[] args)       {              creator1 = new ConcreteCreator1();              prod1 = creator1.factory();              System.out.println("----------------------------");              creator2 = new ConcreteCreator2();              prod2 = creator2.factory();       }}

----抽象工廠

    抽象工廠：多個抽象產品類，派生出多個具體產品類；一個抽象工廠類，派生出多個具體工廠類；每個具體工廠類可建立多個具體產品類的執行個體。

    即提供一個建立一系列相關或相互依賴對象的介面，而無需指定他們的具體的類。“一對多”的關係。

優點：

1、抽象原廠模式隔離了具體類的生產，使得客戶並不需要知道什麼被建立。

2、當一個產品族中的多個對象被設計成一起工作時，它能保證用戶端始終只使用同一個產品族中的對象。

3、增加新的具體工廠和產品族很方便，無須修改已有系統，符合“開閉原則”。

 

缺點：

增加新的產品等級結構很複雜，需要修改抽象工廠和所有的具體工廠類，對“開閉原則”的支援呈現傾斜性。

適用環境：

1、一個系統不應當依賴於產品類執行個體如何被建立、組合和表達的細節，這對於所有類型的原廠模式都是重要的。

2、系統中有多於一個的產品族，而每次只使用其中某一產品族。

3、屬於同一個產品族的產品將在一起使用，這一約束必須在系統的設計中體現出來。

4、系統提供一個產品類的庫，所有的產品以同樣的介面出現，從而使用戶端不依賴於具體實現。

抽象工廠：

//定義不同的產品之間的一定具備的標準，用interface實現 //其中的method()方法可看作提取出不同產品的共性，如手機都有類似的功能 interface IProductA{   public void method(); } interface IProductB{   public void method(); } //實現了產品標準實現的一系列具體產品 //由於已經設計好A1由廠商1生產，故以下輸出代碼有“廠商x” class ProductA1 implements IProductA{   public void method() {     System.out.println("廠商1    生產ProductA1 ...");   } } class ProductA2 implements IProductA{   public void method() {     System.out.println("廠商2    生產ProductA2 ...");   } } class ProductB1 implements IProductB{   public void method() {     System.out.println("廠商1    生產ProductB1 ...");   } } class ProductB2 implements IProductB{   public void method() {     System.out.println("廠商2    生產ProductB2 ...");   } } //每一種牌子的產品生產工廠，即不同的廠商負責自己牌子產品的生產 abstract class Factory1{   abstract IProductA getProductA1();   abstract IProductB getProductB1(); } abstract class Factory2{   abstract IProductA getProductA2();   abstract IProductB getProductB2(); } //具體的工廠用來生產相關的產品 class ConcreteFactory1 extends Factory1{   public IProductA getProductA1() {     return new ProductA1();   }   public IProductB getProductB1() {     return new ProductB1();   } } class ConcreteFactoryB extends Factory2{   public IProductA getProductA2() {     return new ProductA2();   }   public IProductB getProductB2() {     return new ProductB2();   } } //測試類別 public class Client {   public static void main(String[] args) {     //廠商1負責生產產品A1、B1     Factory1 factory1 = new ConcreteFactory1();     IProductA productA1 = factory1.getProductA1();     IProductB productB1 = factory1.getProductB1();          productA1.method();     productB1.method();          //廠商2負責生產產品A2、B2     Factory2 factory2 = new ConcreteFactoryB();     IProductA productA2 = factory2.getProductA2();     IProductB productB2 = factory2.getProductB2();          productA2.method();     productB2.method();   } }

    抽象Factory 方法從縱向上看，幾乎沒有可擴充性，假如我們想增加一個產品C，也就是說產品家族由原來的2個變為3個，程式將會有很大的變動，抽象工廠中就需要增加一個方法。這嚴重違背了開閉原則。並且抽象類別是不喜歡被修改的。

    但是從橫向上來看，卻對擴充性有了很好的支援，如果我們增加一個產品等級3，我們只需要在寫一個Create3就可以了，這裡又符合了開閉原則，有多少個產品等級就應該有多少個實現工廠類。每增加一個產品等級就相應的增加一個實現工廠類，這裡的擴充性又很自然的體現出來了。

應用情境

Factory 方法：

在以下情況下，適用於Factory 方法模式：

(1) 當一個類不知道它所必須建立的對象的類的時候。

(2) 當一個類希望由它的子類來指定它所建立的對象的時候。

(3) 當類將建立對象的職責委託給多個協助子類中的某一個，並且你希望將哪一個協助子類是代理者這一資訊局部化的時候。

抽象工廠：

(1) 一個系統不應當依賴於產品類執行個體如何被建立、組合和表達的細節，這對於所有形態的原廠模式都是重要的。

(2) 這個系統有多於一個的產品族，而系統只消費其中某一產品族。

(3) 同屬於同一個產品族的產品是在一起使用的，這一約束必須在系統的設計中體現出來。

(4) 系統提供一個產品類的庫，所有的產品以同樣的介面出現，從而使用戶端不依賴於實現。

轉載請註明出處：http://blog.csdn.net/df1012890048/article/details/38672341