工廠模式分類：

1、簡單工廠模式

2、多方法靜態工廠

3、工廠方法模式

4、抽象工廠模式

其中工廠方法和抽象工廠是GoF23種設計模式中的一種，而簡單工廠和多方法靜態工廠則不是其中一種設計模式，更加可以理解的是一種編碼時候預定俗稱的一種習慣（常用）。

先帶大家夥入個門~ 從簡單工廠和多方法靜態工廠入門~~

1、簡單工廠模式

簡單工廠：通過實例化一個工廠類，來獲取對應的產品實例。我們不需要關注產品本身如何被創建的細節，只需要通過相應的工廠就可以獲得相應的實例。簡單工廠包括三種角色：

1.工廠：簡單工廠模式的核心，它負責實現創建所有實例的內部邏輯。工廠類的創建產品類的方法可以被外界直接調用，創建所需的產品對象。

2.抽象產品 ：簡單工廠模式所創建的所有對象的父類，它負責描述所有實例所共有的公共接口。

3.具體產品：是簡單工廠模式的創建目標，所有創建的對象都是充當這個角色的某個具體類的實例。

實例：

1.1定義一個Drinks

Drinks作為產品的抽象類並且有抽象方法produce();（抽象產品）

packagecn.design.factorymethod.simplefactory;

/**
*@authorlin
*@version1.0
*@date2020-07-1616:53
*@DescriptionDrinks作為產品的抽象類並且有抽象方法produce();（抽象產品）
*/
publicabstractclassDrinks{
 

protectedabstractvoidproduce();

}

1.2定義一個Sprite

2.Sprite繼承Drinks是要被具體生產出來的產品，他重寫了produce（）方法。（具體產品）

packagecn.design.factorymethod.simplefactory;

/**
*@authorlin
*@version1.0
*@date2020-07-1616:53
*@Description2.Sprite繼承Drinks是要被具體生產出來的產品，他重寫了produce（）方法。（具體產品）
*/
publicclassSpriteextendsDrinks{
@Override
protectedvoidproduce(){
 
System.out.println("drinksprite");
}
}

1.3定義一個Cola

3.Cola同樣也繼承了Drinks，是要被生產出來的具體產品。

packagecn.design.factorymethod.simplefactory;

/**
*@authorlin
*@version1.0
*@date2020-07-1616:56
*@Description3.Cola同樣也繼承了Drinks，是要被生產出來的具體產品。
*/
publicclassColaextendsDrinks{
@Override
protectedvoidproduce(){
System.out.println("DrinkCola");
}
}

1.4定義一個DrinksFactory

4.DrinksFactory為簡單工廠，向外暴露produceDrink方法來獲取產品的實例（工廠）

packagecn.design.factorymethod.simplefactory;

/**
*@authorlin
*@version1.0
*@date2020-07-1616:57
*@Description4.DrinksFactory為簡單工廠，向外暴露produceDrink方法來獲取產品的實例（工廠）
*/
publicclassDrinksFactory{

publicDrinksproduceDrink(ClassclassName){
try{
return(Drinks)Class.forName(className.getName()).newInstance();
}catch(InstantiationException|IllegalAccessException|ClassNotFoundExceptione){
e.printStackTrace();
}

returnnull;
}

}

1.5定義測試類

packagecn.design.factorymethod.simplefactory;

/**
*@authorlin
*@version1.0
*@date2020-07-1618:20
*@Description5.Client為應用層，Client端想要獲取到Cola或者Sprite對象，只要通過DrinkFactory中的produceDrink方法傳入相對應的對應的產品
*/
publicclassClient{
publicstaticvoidmain(String[]args){
DrinksFactoryfactory=newDrinksFactory();
Colacola=(Cola)factory.produceDrink(Cola.class);
cola.produce();
Drinkssprite=factory.produceDrink(Sprite.class);
sprite.produce();
}
}

運行結果如下:

DrinkCola
drinksprite

1.6優缺點

簡單工廠的優點：
1.不需要關心類的創建細節。
2.減輕類之間的耦合依賴，具體類的實現只是依賴於簡單工廠，而不依賴其他類。

簡單工廠的缺點：
1.擴展復雜，當簡單工廠需要生產出另外一種產品的時候，需要擴展工廠的內部創建邏輯，比較有可能引起較大的故障
2.由於工廠類集中了所有實例的創建邏輯，違反了高內聚責任分配原則，將全部創建邏輯集中到了一個工廠類中

2、多方法靜態工廠

我們知道，上面的簡單工廠模式有一個缺點是不同的產品需要不同的額外參數的時候，是不支持的，

而且如果使用時傳遞的type、Class出錯，將不能得到正確的對象，容錯率不高。

而多方法的工廠模式為不同產品，提供不同的生產方法，使用時 需要哪種產品就調用該種產品的方法，使用方便、容錯率高。

請看下面的例子。

定義一個StaticDrinksFactory

packagecn.design.factorymethod.simplefactory;

/**
*@authorlin
*@version1.0
*@date2020-07-1618:57
*@DescriptionTODO
*/
publicclassStaticDrinksFactory{

publicstaticDrinkscreateCola(){
returnnewCola();
}

publicstaticDrinkscreateSprite(){
returnnewSprite();
}
}

定義一個測試類

packagecn.design.factorymethod.simplefactory;

/**
*@authorlin
*@version1.0
*@date2020-07-1618:20
*@Description5.Client為應用層，Client端想要獲取到Cola或者Sprite對象，只要通過DrinkFactory中的produceDrink方法傳入相對應的對應的產品
*/
publicclassClient2{
publicstaticvoidmain(String[]args){
Drinkscola=StaticDrinksFactory.createCola();
cola.produce();
Drinkssprite=StaticDrinksFactory.createSprite();
sprite.produce();
}
}

運行結果如下:

DrinkCola
drinksprite

3、工廠方法模式

在Factory Method模式中，父類決定實例的生成方式，但並不決定所要生成的具體的類，具體的處理全部交給子類負責。這樣就可以將生成實例的框架(framework)和實際負責生成實例的類解耦。

實例：

類的功能一覽表：

Product只定義抽象方法use的抽象類

Factory實現了create方法的抽象類

IDCard實現了use方法的類

IDCardFactory實現了createProduct、registerProduct方法的類

EmailCard實現了use方法的類

EmailCardFactory實現了createProduct、registerProduct方法的類

Main測試程序行為的類

3.1定義Product類

packagecn.design.factorymethod.framework;

/**
*@authorlin
*@version1.0
*@date2020-07-1615:53
*@DescriptionTODO
*/
publicabstractclassProduct{
publicabstractvoiduse();
}

3.2定義Factory類

packagecn.design.factorymethod.framework;

/**
*@authorlin
*@version1.0
*@date2020-07-1615:55
*@DescriptionTODO
*/
publicabstractclassFactory{

publicfinalProductcreate(Stringowner){
Productproduct=createProduct(owner);
registerProduct(product);
returnproduct;
}

protectedabstractProductcreateProduct(Stringowner);

protectedabstractvoidregisterProduct(Productproduct);
}

3.3定義IDCard類

packagecn.design.factorymethod.idcard;

importcn.design.factorymethod.framework.Product;

/**
*@authorlin
*@version1.0
*@date2020-07-1616:00
*@DescriptionTODO
*/
publicclassIDCardextendsProduct{
privateStringowner;

publicIDCard(Stringowner){
this.owner=owner;
System.out.println("制作"+owner+"的ID卡");
}

@Override
publicvoiduse(){
System.out.println("使用"+owner+"的ID卡");
}

publicStringgetOwner(){
returnowner;
}

publicvoidsetOwner(Stringowner){
this.owner=owner;
}
}

3.4定義IDCardFactory類

packagecn.design.factorymethod.idcard;

importcn.design.factorymethod.framework.Factory;
importcn.design.factorymethod.framework.Product;

importjava.util.ArrayList;
importjava.util.List;

/**
*@authorlin
*@version1.0
*@date2020-07-1616:02
*@DescriptionTODO
*/
publicclassIDCardFactoryextendsFactory{
privateList<String>owners=newArrayList<>();

@Override
protectedProductcreateProduct(Stringowner){
returnnewIDCard(owner);
}

@Override
protectedvoidregisterProduct(Productproduct){
owners.add(((IDCard)product).getOwner());
}

publicList<String>getOwners(){
returnowners;
}
}

3.5定義EmailCard類

packagecn.design.factorymethod.idcard;

importcn.design.factorymethod.framework.Product;

/**
*@authorlin
*@version1.0
*@date2020-07-1616:00
*@DescriptionTODO
*/
publicclassEmailCardextendsProduct{
privateStringemail;

publicEmailCard(Stringowner){
this.email=owner;
System.out.println("制作email卡:"+owner);
}

@Override
publicvoiduse(){
System.out.println("使用email卡:"+email);
}

publicStringgetEmail(){
returnemail;
}

publicvoidsetEmail(Stringemail){
this.email=email;
}
}

3.6定義EmailCardFactory類

packagecn.design.factorymethod.idcard;

importcn.design.factorymethod.framework.Factory;
importcn.design.factorymethod.framework.Product;

importjava.util.ArrayList;
importjava.util.List;

/**
*@authorlin
*@version1.0
*@date2020-07-1616:02
*@DescriptionTODO
*/
publicclassEmailCardFactoryextendsFactory{
privateList<String>emails=newArrayList<>();

@Override
protectedProductcreateProduct(Stringemail){
returnnewEmailCard(email);
}

@Override
protectedvoidregisterProduct(Productproduct){
emails.add(((EmailCard)product).getEmail());
}

publicList<String>getEmails(){
returnemails;
}
}

3.7定義Main測試類

packagecn.design.factorymethod;

importcn.design.factorymethod.framework.Factory;
importcn.design.factorymethod.framework.Product;
importcn.design.factorymethod.idcard.EmailCardFactory;
importcn.design.factorymethod.idcard.IDCardFactory;
importcom.sun.org.apache.bcel.internal.generic.NEW;

/**
*@authorlin
*@version1.0
*@date2020-07-1615:43
*@DescriptionTODO
*/
publicclassTestMain{
publicstaticvoidmain(String[]args){
Factoryfactory=newIDCardFactory();
Productp1=factory.create("小明");
p1.use();
EmailCardFactoryfactory2=newEmailCardFactory();
Productp2=factory2.create("123@qq.com");
p2.use();
}

}

運行結果如下:

制作小明的ID卡
使用小明的ID卡
制作email卡:123@qq.com
使用email卡:123@qq.com

優點

更符合開-閉原則 新增一種產品時，只需要增加相應的具體產品類和相應的工廠子類即可

簡單工廠模式需要修改工廠類的判斷邏輯

符合單一職責原則 每個具體工廠類只負責創建對應的產品

簡單工廠中的工廠類存在復雜的switch邏輯判斷

不使用靜態工廠方法，可以形成基於繼承的等級結構。

簡單工廠模式的工廠類使用靜態工廠方法

總結：工廠模式可以說是簡單工廠模式的進一步抽象和拓展，在保留了簡單工廠的封裝優點的同時，讓擴展變得簡單，讓繼承變得可行，增加了多態性的體現。

缺點

添加新產品時，除了增加新產品類外，還要提供與之對應的具體工廠類，系統類的個數將成對增加，在一定程度上增加了系統的復雜度；同時，有更多的類需要編譯和運行，會給系統帶來一些額外的開銷；

由於考慮到系統的可擴展性，需要引入抽象層，在客戶端代碼中均使用抽象層進行定義，增加了系統的抽象性和理解難度，且在實現時可能需要用到DOM、反射等技術，增加了系統的實現難度。

雖然保證了工廠方法內的對修改關閉，但對於使用工廠方法的類，如果要更換另外一種產品，仍然需要修改實例化的具體工廠類； 一個具體工廠只能創建一種具體產品

應用場景

在了解了優缺點後，我總結了工廠方法模式的應用場景：

當一個類不知道它所需要的對象的類時在工廠方法模式中，客戶端不需要知道具體產品類的類名，只需要知道所對應的工廠即可；當一個類希望通過其子類來指定創建對象時在工廠方法模式中，對於抽象工廠類只需要提供一個創建產品的接口，而由其子類來確定具體要創建的對象，利用面向對象的多態性和裡氏代換原則，在程序運行時，子類對象將覆蓋父類對象，從而使得系統更容易擴展。將創建對象的任務委託給多個工廠子類中的某一個，客戶端在使用時可以無須關心是哪一個工廠子類創建產品子類，需要時再動態指定，可將具體工廠類的類名存儲在配置文件或數據庫中。

發哥講

如果你覺得文章還不錯，就請點擊右上角選擇發送給朋友或者轉發到朋友圈~

●掃碼關注公眾號