2. 程式人生 > >設計模式之四-Factory模式

設計模式之四-Factory模式

阿新 • • 發佈：2017-05-09
無需 告訴 實現 比較 原則 更強 方便 可能 fprintf

簡單工廠模式

簡單工廠模式是工廠模式中最簡單的一種，他可以用比較簡單的方式隱藏創建對象的細節，一般只需要告訴工廠類所需要的類型，工廠類就會返回需要的產品類，但客戶端看到的只是產品的抽象對象，無需關心到底是返回了哪個子類。客戶端唯一需要知道的具體子類就是工廠子類。除了這點，基本是達到了依賴倒轉原則的要求。

假如，我們不用工廠類，只用AbstractProduct和它的子類，那客戶端每次使用不同的子類的時候都需要知道到底是用哪一個子類，當類比較少的時候還沒什麽問題，但是當類比較多的時候，管理起來就非常的麻煩了，就必須要做大量的替換，一個不小心就會發生錯誤。

而使用了工廠類之後，就不會有這樣的問題，不管裏面多少個類，我只需要知道類型號即可。不過，這裏還有一個疑問，那就是如果我每次用工廠類創建的類型都不相同，這樣修改起來的時候還是會出現問題，還是需要大量的替換。所以簡單工廠模式一般應該於程序中大部分地方都只使用其中一種產品，工廠類也不用頻繁創建產品類的情況。這樣修改的時候只需要修改有限的幾個地方即可。

技術分享

客戶只需要知道SimpleFactory就可以了，使用的時候也是使用的AbstractFactory，這樣客戶端只在第一次創建工廠的時候是知道具體的細節的，其他時候它都只知道AbstractFactory，這樣就完美的達到了依賴倒轉的原則。

常用的場景

例如部署多種數據庫的情況，可能在不同的地方要使用不同的數據庫，此時只需要在配置文件中設定數據庫的類型，每次再根據類型生成實例，這樣，不管下面的數據庫類型怎麽變化，在客戶端看來都是只有一個AbstractProduct，使用的時候根本無需修改代碼。提供的類型也可以用比較便於識別的字符串，這樣不用記很長的類名，還可以保存為配置文件。

這樣，每次只需要修改配置文件和添加新的產品子類即可。

所以簡單工廠模式一般應用於多種同類型類的情況，將這些類隱藏起來，再提供統一的接口，便於維護和修改。

優點

1.隱藏了對象創建的細節，將產品的實例化推遲到子類中實現。

2.客戶端基本不用關心使用的是哪個產品，只需要知道用哪個工廠就行了，提供的類型也可以用比較便於識別的字符串。

3.方便添加新的產品子類，每次只需要修改工廠類傳遞的類型值就行了。

4.遵循了依賴倒轉原則。

缺點

1.要求產品子類的類型差不多，使用的方法名都相同，如果類比較多，而所有的類又必須要添加一種方法，則會是非常麻煩的事情。或者是一種類另一種類有幾種方法不相同，客戶端無法知道是哪一個產品子類，也就無法調用這幾個不相同的方法。

2.每添加一個產品子類，都必須在工廠類中添加一個判斷分支，這違背了開放-封閉原則。

C++實現代碼

#ifndef _ABSTRACTPRODUCT_H_
#define _ABSTRACTPRODUCT_H_


#include <stdio.h>


class AbstractProduct{

public:
    AbstractProduct();
    virtual ~AbstractProduct();
    
public:
    virtual void operation() = 0;
};

class ProductA:public AbstractProduct{

public:
    ProductA();
    virtual ~ProductA();
    
public:
    void operation();
};

class ProductB:public AbstractProduct{

public:
    ProductB();
    ~ProductB();
    
public:
    void operation();
};

#endif

AbstractProduct.h
#include "AbstractProduct.h"



AbstractProduct::AbstractProduct(){
}


AbstractProduct::~AbstractProduct(){
}


ProductA::ProductA(){
}


ProductA::~ProductA(){
}


void ProductA::operation(){
    fprintf(stderr,"productA operation!\n");
}


ProductB::ProductB(){
}


ProductB::~ProductB(){
}


void ProductB::operation(){
    fprintf(stderr,"productB operation!\n");
}

AbstractProduct.cpp
#ifndef _SIMPLEFACTORY_H_
#define _SIMPLEFACTROY_H_

#include <stdio.h>
#include "AbstractProduct.h"


class AbstractFactory{

public:
    AbstractFactory();
    virtual ~AbstractFactory();
    
public:
    virtual AbstractProduct* createProduct(int type) = 0;    
};


class SimpleFactory:public AbstractFactory{

public:
    SimpleFactory();
    ~SimpleFactory();
    
public:
    AbstractProduct* createProduct(int type);
};

#endif

SimpleFactory.h
#include "SimpleFactory.h"


AbstractFactory::AbstractFactory(){
}


AbstractFactory::~AbstractFactory(){
}


SimpleFactory::SimpleFactory(){
}


SimpleFactory::~SimpleFactory(){
}


AbstractProduct* SimpleFactory::createProduct(int type){
    AbstractProduct* temp = NULL;
    switch(type)
    {
    case 1:
        temp = new ProductA();
        break;
    case 2:
        temp = new ProductB();
        break;
    default:
        break;
    }
    return temp;
}

SimpleFactory.cpp
#include "SimpleFactory.h"


int main(){
    AbstractFactory* factory = new SimpleFactory();
    AbstractProduct* product = factory->createProduct(1);
    product->operation();
    delete product;
    product = NULL;
    
    product = factory->createProduct(2);
    product->operation();
    delete product;
    product = NULL;
    return 0;
}

client.cpp

工廠模式

工廠模式基本與簡單工廠模式差不多，上面也說了，每次添加一個產品子類都必須在工廠類中添加一個判斷分支，這樣違背了開放-封閉原則，因此，工廠模式就是為了解決這個問題而產生的。

既然每次都要判斷，那我就把這些判斷都生成一個工廠子類，這樣，每次添加產品子類的時候，只需再添加一個工廠子類就可以了。這樣就完美的遵循了開放-封閉原則。但這其實也有問題，如果產品數量足夠多，要維護的量就會增加，好在一般工廠子類只用來生成產品類，只要產品子類的名稱不發生變化，那麽基本工廠子類就不需要修改，每次只需要修改產品子類就可以了。

同樣工廠模式一般應該於程序中大部分地方都只使用其中一種產品，工廠類也不用頻繁創建產品類的情況。這樣修改的時候只需要修改有限的幾個地方即可。

技術分享

常用的場景

基本與簡單工廠模式一致，只不過是改進了簡單工廠模式中的開放-封閉原則的缺陷，使得模式更具有彈性。將實例化的過程推遲到子類中，由子類來決定實例化哪個。

優點

基本與簡單工廠模式一致，多的一點優點就是遵循了開放-封閉原則，使得模式的靈活性更強。

缺點

與簡單工廠模式差不多。

C++實現代碼

#ifndef _ABSTRACTPRODUCT_H_
#define _ABSTRACTPRODUCT_H_


#include <stdio.h>


class AbstractProduct{

public:
    AbstractProduct();
    virtual ~AbstractProduct();
    
public:
    virtual void operation() = 0;
};

class ProductA:public AbstractProduct{

public:
    ProductA();
    virtual ~ProductA();
    
public:
    void operation();
};

class ProductB:public AbstractProduct{

public:
    ProductB();
    ~ProductB();
    
public:
    void operation();
};

#endif

AbstractProduct.h
#include "AbstractProduct.h"



AbstractProduct::AbstractProduct(){
}


AbstractProduct::~AbstractProduct(){
}


ProductA::ProductA(){
}


ProductA::~ProductA(){
}


void ProductA::operation(){
    fprintf(stderr,"productA operation!\n");
}


ProductB::ProductB(){
}


ProductB::~ProductB(){
}


void ProductB::operation(){
    fprintf(stderr,"productB operation!\n");
}

AbstractProduct.cpp
#ifndef _SIMPLEFACTORY_H_
#define _SIMPLEFACTROY_H_

#include <stdio.h>
#include "AbstractProduct.h"


class AbstractFactory{

public:
    AbstractFactory();
    virtual ~AbstractFactory();
    
public:
    virtual AbstractProduct* createProduct() = 0;    
};


class FactoryA:public AbstractFactory{

public:
    FactoryA();
    ~FactoryA();
    
public:
    AbstractProduct* createProduct();
};


class FactoryB:public AbstractFactory{

public:
    FactoryB();
    ~FactoryB();
    
public:
    AbstractProduct* createProduct();
};
#endif

AbstractFactory.h
#include "AbstractFactory.h"


AbstractFactory::AbstractFactory(){
}


AbstractFactory::~AbstractFactory(){
}


FactoryA::FactoryA(){
}


FactoryA::~FactoryA(){
}


AbstractProduct* FactoryA::createProduct(){
    AbstractProduct* temp = NULL;
    temp = new ProductA();
    return temp;
}


FactoryB::FactoryB(){
}


FactoryB::~FactoryB(){
}


AbstractProduct* FactoryB::createProduct(){
    AbstractProduct* temp = NULL;
    temp = new ProductB();
    return temp;
}

AbstractFactory.cpp
#include "AbstractFactory.h"


int main(){
    AbstractFactory* factory = new FactoryA();
    AbstractProduct* product = factory->createProduct();
    product->operation();
    delete product;
    product = NULL;
    delete factory;
    factory = NULL;
    
    factory = new FactoryB();
    product = factory->createProduct();
    product->operation();
    delete product;
    product = NULL;
    delete factory;
    factory = NULL;
    return 0;
}

client.cpp

抽象工廠模式

抽象工廠模式就變得比工廠模式更為復雜，就像上面提到的缺點一樣，工廠模式和簡單工廠模式要求產品子類必須要是同一類型的，擁有共同的方法，這就限制了產品子類的擴展。於是為了更加方便的擴展，抽象工廠模式就將同一類的產品子類歸為一類，讓他們繼承同一個抽象子類，我們可以把他們一起視作一組，然後好幾組產品構成一族。

此時，客戶端要使用時必須知道是哪一個工廠並且是哪一組的產品抽象類。每一個工廠子類負責產生一族產品，而子類的一種方法產生一種類型的產品。在客戶端看來只有AbstractProductA和AbstractProductB兩種產品，使用的時候也是直接使用這兩種產品。而通過工廠來識別是屬於哪一族產品。

技術分享

產品ProductA_1和ProductB_1構成一族產品，對應於有Factory1來創建，也就是說Factory1總是創建的ProductA_1和ProductB_1的產品，在客戶端看來只需要知道是哪一類工廠和產品組就可以了。一般來說， ProductA_1和ProductB_1都是適應同一種環境的，所以他們會被歸為一族。

常用的場景

例如Linux和windows兩種操作系統下，有2個掛件A和B，他們在Linux和Windows下面的實現方式不同，Factory1負責產生能在Linux下運行的掛件A和B，Factory2負責產生能在Windows下運行的掛件A和B，這樣如果系統環境發生變化了，我們只需要修改工廠就行了。

優點

1.封裝了產品的創建，使得不需要知道具體是哪種產品，只需要知道是哪個工廠就行了。

2.可以支持不同類型的產品，使得模式靈活性更強。

3.可以非常方便的使用一族中間的不同類型的產品。

缺點

1.結構太過臃腫，如果產品類型比較多，或者產品族類比較多，就會非常難於管理。

2.每次如果添加一組產品，那麽所有的工廠類都必須添加一個方法，這樣違背了開放-封閉原則。所以一般適用於產品組合產品族變化不大的情況。

C++實現代碼

#ifndef _ABSTRACTPRODUCTA_H_
#define _ABSTRACTPRODUCTA_H_


#include <stdio.h>


class AbstractProductA{

public:
    AbstractProductA();
    virtual ~AbstractProductA();
    
public:
    virtual void operationA() = 0;
};

class ProductA_1:public AbstractProductA{

public:
    ProductA_1();
    virtual ~ProductA_1();
    
public:
    void operationA();
};

class ProductA_2:public AbstractProductA{

public:
    ProductA_2();
    ~ProductA_2();
    
public:
    void operationA();
};

#endif

AbstractProductA.h
#include "AbstractProductA.h"



AbstractProductA::AbstractProductA(){
}


AbstractProductA::~AbstractProductA(){
}


ProductA_1::ProductA_1(){
}


ProductA_1::~ProductA_1(){
}


void ProductA_1::operationA(){
    fprintf(stderr,"productA_1 operation!\n");
}


ProductA_2::ProductA_2(){
}


ProductA_2::~ProductA_2(){
}


void ProductA_2::operationA(){
    fprintf(stderr,"productA_2 operation!\n");
}

AbstractProductA.cpp
#ifndef _ABSTRACTPRODUCTB_H_
#define _ABSTRACTPRODUCTB_H_


#include <stdio.h>


class AbstractProductB{

public:
    AbstractProductB();
    virtual ~AbstractProductB();
    
public:
    virtual void operationB() = 0;
};

class ProductB_1:public AbstractProductB{

public:
    ProductB_1();
    virtual ~ProductB_1();
    
public:
    void operationB();
};

class ProductB_2:public AbstractProductB{

public:
    ProductB_2();
    ~ProductB_2();
    
public:
    void operationB();
};

#endif

AbstractProductB.h
#include "AbstractProductB.h"



AbstractProductB::AbstractProductB(){
}


AbstractProductB::~AbstractProductB(){
}


ProductB_1::ProductB_1(){
}


ProductB_1::~ProductB_1(){
}


void ProductB_1::operationB(){
    fprintf(stderr,"productB_1 operation!\n");
}


ProductB_2::ProductB_2(){
}


ProductB_2::~ProductB_2(){
}


void ProductB_2::operationB(){
    fprintf(stderr,"productB_2 operation!\n");
}

AbstractProductB.cpp
#ifndef _SIMPLEFACTORY_H_
#define _SIMPLEFACTROY_H_

#include <stdio.h>
#include "AbstractProductA.h"
#include "AbstractProductB.h"


class AbstractFactory{

public:
    AbstractFactory();
    virtual ~AbstractFactory();
    
public:
    virtual AbstractProductA* createProductA() = 0;    
    virtual AbstractProductB* createProductB() = 0;    
};


class Factory1:public AbstractFactory{

public:
    Factory1();
    ~Factory1();
    
public:
    AbstractProductA* createProductA();
    AbstractProductB* createProductB();
};


class Factory2:public AbstractFactory{

public:
    Factory2();
    ~Factory2();
    
public:
    AbstractProductA* createProductA();
    AbstractProductB* createProductB();
};
#endif

AbstractFactory.h
#include "AbstractFactory.h"


AbstractFactory::AbstractFactory(){
}


AbstractFactory::~AbstractFactory(){
}


Factory1::Factory1(){
}


Factory1::~Factory1(){
}


AbstractProductA* Factory1::createProductA(){
    AbstractProductA* temp = NULL;
    temp = new ProductA_1();
    return temp;
}


AbstractProductB* Factory1::createProductB(){
    AbstractProductB* temp = NULL;
    temp = new ProductB_1();
    return temp;
}


Factory2::Factory2(){
}


Factory2::~Factory2(){
}


AbstractProductA* Factory2::createProductA(){
    AbstractProductA* temp = NULL;
    temp = new ProductA_2();
    return temp;
}


AbstractProductB* Factory2::createProductB(){
    AbstractProductB* temp = NULL;
    temp = new ProductB_2();
    return temp;
}

AbstractFactory.cpp
#include "AbstractFactory.h"


int main(){

    AbstractFactory* factory = new Factory1();
    AbstractProductA* productA = factory->createProductA();
    AbstractProductB* productB = factory->createProductB();
    productA->operationA();
    productB->operationB();
    
    delete factory;
    factory = NULL;
    delete productA;
    productA = NULL;
    delete productB;
    productB = NULL;
    
    factory = new Factory2();
    productA = factory->createProductA();
    productB = factory->createProductB();
    productA->operationA();
    productB->operationB();
    
    delete factory;
    factory = NULL;
    delete productA;
    productA = NULL;
    delete productB;
    productB = NULL;
    return 0;
}

client.cpp

轉載自http://www.cnblogs.com/cxjchen/p/3143633.html

設計模式之四-Factory模式

相關推薦

設計模式之四-Factory模式

無需 告訴 實現 比較 原則 更強 方便 可能 fprintf 簡單工廠模式 簡單工廠模式是工廠模式中最簡單的一種，他可以用比較簡單的方式隱藏創建對象的細節，一般只需要告訴工廠類所需要的類型，工廠類就會返回需要的產品類，但客戶端看到的只是產品的抽象對象，無需關心到底是

設計模式之Static Factory模式(簡單工廠模式)

簡單工廠模式並不是GOF提出的23種設計模式中的一種。工廠模式有一種非常形象的描述,建立物件的類就如一個工廠,而需要被建立的物件就是一個個產品。 適用場合 1.在程式中，需要建立的物件很多，導致物件的new操作多且雜時，需要使用簡單工廠模式； 2.由於物件的建立過程是我們不

Java進階篇設計模式之四 -----介面卡模式和橋接模式

前言 在上一篇中我們學習了建立型模式的建造者模式和原型模式。本篇則來學習下結構型模式的介面卡模式和橋接模式。 介面卡模式 簡介 介面卡模式是作為兩個不相容的介面之間的橋樑。這種型別的設計模式屬於結構型模式，它結合了兩個獨立介面的功能。 簡單的來說就是通過某個介面將不相容的兩個類進行相容，俗稱轉換器。 生活

【設計模式攻略】建立型模式之Abstract Factory模式

概要 Abstract factory模式其實就是普通factory模式的一種進化，它比較側重於對一個系列中相關多個物件的建立工作。何謂一個系列？其實就是某種客觀條件下滿足特定需求的一組物件集合。當面對多個系列時，需要實現每個系列的例項化的Factory，這時使用一般的Factory模式往往讓過程變得複雜，而

設計思想與模式之四靜態代理模式

test 創建 靜態代理 pan 代理 對象的訪問 override todo 父類 一 概述 1.什麽是代理模式？ 為了隱藏與保護目標對象，為其他對象提供一個代理以控制對該目標對象的訪問。 2.什麽是靜態代理模式？ 代理模式有兩種： 靜態代理：代理對象固定。 動態代理：

C#設計模式之四抽象工廠模式（AbstractFactory）【創建型】

抽象 抽象工廠 album 代碼 ctf bst actor 抽象工廠模式 .cn 一、引言 寫了3篇有關設計模式的文章了，大家有了些反饋，說能從中學到一些東西，我感到很欣慰，那就繼續努力。今天我要寫第四個模式了，該模式叫抽象工廠。上一篇文章我們講了【工廠方法】模式，它是為

Java進階篇設計模式之四 -----適配器模式和橋接模式

原則 pub 是我 protect 接口 logs 將不 多說 外鏈 前言 在上一篇中我們學習了創建型模式的建造者模式和原型模式。本篇則來學習下結構型模式的適配器模式和橋接模式。 適配器模式 簡介 適配器模式是作為兩個不兼容的接口之間的橋梁。這種類型的設計模式屬於結構型模

設計模式---對象創建模式之抽象工廠模式（Abstract Factory）

變化 實現 clas span 有關 數據庫 數據庫連接 不同的 面向 一：概念 抽象工廠模式是所有形態的工廠模式中最為抽象和最具一般性的。抽象工廠模式可以向客戶端提供一個接口，使得客戶端在不必指定產品的具體類型的情況下，能夠創建多個產品族的產品對象 二：動機

設計模式之簡單工廠模式( Simple Factory Pattern )

1. 簡單工廠模式( Simple Factory Pattern ) 目錄 簡單工廠模式( Simple Factory Pattern ) 模式動機 模式定義 模式結構 時序圖 程式碼分析 模式分析 例項

設計模式之抽象工廠模式(Abstract Factory)

3. 抽象工廠模式(Abstract Factory) 目錄 抽象工廠模式(Abstract Factory) 模式動機 模式定義 模式結構 時序圖 程式碼分析 模式分析 例項 優點 缺點

設計模式之工廠方法模式(Factory Method Pattern)

2. 工廠方法模式(Factory Method Pattern) 目錄 工廠方法模式(Factory Method Pattern) 模式動機 模式定義 模式結構 時序圖 程式碼分析 模式分析 例項

（四） 設計模式之抽象工廠模式

前面已經說過了簡單工廠模式和普通工廠模式：連結 前沿： 參考圖書：《軟體設計模式與體系結構》   抽象工廠就是普通工廠模式的加強版本 優點：當一個產品族中的多個物件被設計成一起工作時，它能保證客戶端始終只使用同一個產品族中的物件。 使用場景： 1、QQ

設計模式之：工廠模式(factory)

工廠模式factory 工廠模式其主旨在於將物件的建立過程抽取(抽象)出來，形成專門用於統一建立物件的類； 根據不同的建立要求，建立所需要的物件； C++實現 #include<i

23種設計模式之---觀察者模式(Observer Factory)

1.觀察者模式(行為型模式) 觀察者模式定義了一種一對多的依賴關係,讓多個觀察者物件同時監聽某一個主題物件。這個主題物件在狀態發生變化時,會通知所有的觀察者物件,使它們能夠自己更新自己。 2.觀察者模式結構圖 3.觀察者模式結構圖分析 Subject類,可理解為主題或抽象通知者

設計模式筆記之四原型模式

原型模式 為什麼引入原型模式？ 當我們需要建立某個物件的時候，我們使用new關鍵字，但是當我們需要建立兩個相同的物件，接著new,當數量特定少的時候，我們可以採用直接建立物件，但是當我們需要建立很多物件的時候，我們就不能一直new，首先是因為堆記憶體有限，只允許我們new

設計模式之簡單工廠模式（simple factory pattern)

什麼是簡單工廠模式， 舉個不恰當的例子， 就說生產雪糕吧， 雪糕什麼形狀的都有， 有長方形，有圓形等等， 怎麼生產呢？ 首先肯定是先造個機器， 然後弄幾個按鈕，上面依次寫上長方形， 圓形等等，我按長方形就給我出長方形的， 我按圓形的按鈕就給我出圓形的。 大概就是這樣接下來

JAVA設計模式之抽象工廠模式(Abstract Factory)

目錄 在工廠方法模式中具體工廠負責生產具體的產品，每一個具體工廠對應一種具體產品，工廠方法也具有唯一性，一般情況下，一個具體工廠中只有一個工廠方法或者一組過載的工廠方法。但是有時候我們需要一個工廠可以提供多個產品物件，而不是單一的產品物件。 為了更清晰地

程式碼設計模式之工廠方法模式（Factory Method）

特點： 工廠方法是粒度很小的設計模式，因為模式的表現只是一個抽象的方法。提前定義用於建立物件的介面，讓子類決定例項化具體的某一個類，即在工廠和產品中間增加介面，工廠不再負責產品的建立，由介面針對不同條件返回具體的類例項，由具體類例項去實現。工廠方法模式是簡單工廠模式的衍生，

Java設計模式之四（經典面試題：工廠模式在開發中的運用）

面試題：        寫一個簡單的計算器。  程式碼實現： 抽象一個運算類： package com.qianyan.calcuator; public abstract class Operation { //數字一 private double num

設計模式之抽象工程模式Abstract Factory Pattern()C++實現

抽象工廠模式（Abstract Factory Pattern）：是圍繞一個超級工廠建立其他工廠。該超級工廠又稱為其他工廠的工廠。在抽象工廠模式中，介面是負責建立一個相關物件的工廠，不需要顯式指定它們的類。每個生成的工廠都能按照工廠模式提供物件。 意圖：提供一個建立一系列相