對于簡單工廠來說，它的工廠只能是這個樣子的
public class SimplyFactory {
/**
* 靜態工廠方法
*/
public static Prouct factory(String which) throw NoSuchProductExcption
{
if(which.equalIgnoreCase("product1"))
{
return new Product1();
}
else if(which.equalsIgnoreCase("product2"))
{
return new Product2();
}
else if(which.equalsIgnoreCase("product3"))
{
return new Product3();
}
else throw NoSuchProductExcption("NoSuchProduct");
}
}
}
而對產品Product1,Product2,Product3,可以執行接口Product,也可以不執行接口Product（當然這樣不好），這個Product接口只是用來抽象具體product用的
public interface Product
{
void productMethod1(); //這些只是
void productMethod2();
void productMethod3();
}
對工廠來說，只要有這么一種產品，一般來說就要在工廠里有它的生產的方法， 否則拋出異常，而要工廠生產的話，也必須下達生產什么產品的命令，至少要向工廠發出信號，讓工廠足以區分是要生產什么產品，否則工廠是不知道生產哪一種產品，
對于簡單工廠來說，就是需要在工廠中枚舉所有的產品，所以說簡單工廠還是非常笨的。
if(which.equalIgnoreCase("product1")) 只是用來區分生產什么產品的標記值，（也可以根據產品其它屬性來判斷，比如產品類型，產品大小，總之能夠區分是什么產品的屬性，或者是與產品屬性相關的變量） 或者說標記值是A,生產A產品，或者工廠里定義不是這樣的，我偏偏要生產B產品，或者再特殊一些，我偏偏要生產A產品+B產品，那么就要return new ProductA()+new ProductB()了。
這樣，我們就可以看出一個問題來，如果要能夠被簡單工廠生產出來，就必須在簡單工廠中有能夠生產出的它的方法定義，當然還需要有這個具體產品類的定義，就是有class對應，這樣確保在簡單工廠中new 它的時候不會拋出 NoSuchProduct的Exception.
對于工廠方法來說
實質上它是讓工廠實現了抽象的工廠接口，它把具體怎么生產一種東西，放在具體的工廠去實現了，所謂”延遲到子類中實現“
public interface Creator
{
public Prouct factory();
}
public SubCreator1 implent Creator
{
public Prouct factory()
{
return new ConcreteProduct1();
}
}
public SubCreator2 implent Creator
{
public Prouct factory()
{
return new ConcreteProduct2();
}
}
請注意：返回類型是Product型的！！
這樣客戶端調用是直接new 一個具體工廠的實例，然后命令它去生產，而對于具體工廠的父類（既工廠接口，接口完全可以改成子類繼承父類來實現，只是這樣不好，不符合OO的原則），它完全不知道什么產品被生產了，甚至它連那個具體工廠被實例化它都不知道
抽象工廠模式
抽象工廠模式意圖是“提供一個創建一系列相關或相互依賴對象的接口，而無需指定他們具體的類”或為特定的客戶（或情況）提供特定系列的對象。
public interface Creator
{
public ProuctA factoryA();
public ProuctB factoryB();
}
public interface ProductA //ProductA 接口
{
}
public interface ProductB //ProductB 接口
{
}
public class ConCreator1 implent Creator
{
public ProuctA factoryA()
{
return new ConcreteProductA1();
}
public ProuctB factoryB()
{
return new ConcreteProductB1();
}
}
public class ConCreator2 implent Creator
{
public ProuctA factoryA()
{
return new ProductA2();
}
public ProuctB factoryB()
{
return new ProductB2();
}
}
public class ProductA1 implements ProductA
{
public ProductA1()
{
}
}
public class ProductA2 implements ProductA
{
public ProductA2()
{
}
}
public class ProductB1 implements ProductB
{
public ProductB1()
{
}
}
public class ProductB2 implements ProductB
{
public ProductB2()
{
}
}
實際上是這樣的
1，兩個工廠類ConCreator1，ConCreator2都實現了Creator接口
2，ProuctA1,ProductA2都實現了ProductA接口
3，ProuctB1,ProductB2都實現了ProductB接口
4，ConCreator1負責生產ProductA類型的產品(包括ProductA1，ProductB1)
5，ConCreator2負責生產ProductB類型的產品(包括ProductA2，ProductB2)
6，工廠方法也有這樣的特征，也就是說Creator不知道什么被生產出來，甚至不知道ConCreator1還是ConCreator2被實例化了，因為client高興調那一個工廠，就調那一個工廠，就是說工廠能生產什么，對客戶端是可見的。甚至還有一種情況，客戶端高興起來就生產了ProductA1,我就不生產ProductA2,因為上面的例子中它們還都是松散的，沒有綁定在一起
于是提出另外一個例子，也是老提起的電腦類型的例子
1，電腦生產商是接口，
2，CUP是接口，
3，硬盤是接口，
4，IBM工廠是制造IBM品牌的電腦的工廠
5，DELL工廠是制造DEll品牌的電腦的工廠
為討論方便，就認為電腦=CUP+硬盤；
6，所以呀CUP有IBM的CPU和DELL的CPU
7，同樣硬盤也是有IBM的硬盤和DELL的硬盤
8，IBM工廠生產IBM的CPU和IBM的硬盤，絕對不生產DELL的CPU，也不生產DELL的硬盤
9，同樣DELL工廠也是一樣
public interface 電腦生產商
{
public CPU 制造CPU();
public 硬盤 制造硬盤();
}
public interface CPU
{
}
public interface 硬盤
{
}
public class IBM的CPU implements CPU
{
public IBM的CPU();
}
public class IBM的硬盤 implements 硬盤
{
public IBM的硬盤();
}
public class DELL的CPU implements CPU
{
public DELL的CPU();
}
public class DELL的硬盤 implements 硬盤
{
public DELL的硬盤();
}
//下面是IBM工廠
public class IBM工廠
{
private CPU IBM的CPU私有變量=null;
private 硬盤 IBM的硬盤私有變量=null;
private CPU 制造IBMCPU()
{
return new IBM的CPU();
}
private 硬盤 制造IBM硬盤()
{
return new IBM的CPU();
}
public 電腦 制造IBM電腦()
{
try{
IBM的CPU私有變量=制造IBMCPU();
IBM的硬盤私有變量=制造IBM硬盤();
if(IBM的CPU私有變量!=null&&IBM的硬盤私有變量!=null)
retrun (IBM的CPU私有變量+IBM的硬盤私有變量);
//組裝成IBM電腦
}
catch(Exception e)
{
System.out.println("制造IBM電腦失敗！");
}
}
}
}
這樣，客戶端無法通過命令單生產出一個CPU來，這樣抽象才真正成為一個完整產品的工廠，只要向工廠發出生產的命令，一臺完整的電腦就生產出來了，而工廠怎么生產的，生產了哪些部件，外界就看不見了，外界就知道這個工廠是生產IBM電腦整機的工廠！
DELL電腦工廠一樣
----------------------------總結----------------------------
工廠方法模式：
一個抽象產品類，可以派生出多個具體產品類。
一個抽象工廠類，可以派生出多個具體工廠類。
每個具體工廠類只能創建一個具體產品類的實例。
抽象工廠模式：
多個抽象產品類，每個抽象產品類可以派生出多個具體產品類。
一個抽象工廠類，可以派生出多個具體工廠類。
每個具體工廠類可以創建多個具體產品類的實例。
區別：
工廠方法模式只有一個抽象產品類，而抽象工廠模式有多個。
工廠方法模式的具體工廠類只能創建一個具體產品類的實例，而抽象工廠模式可以創建多個。
posted on 2006-07-18 11:20
保爾任 閱讀(1578)
評論(0) 編輯 收藏 所屬分類:
Design Patten