設計模式：工廠方法模式

之前寫了

 設計模式系列目錄

今天說一下工廠方法模式：

定義了一個創建對象的接口，但由子類決定要實例化的類是哪一個。工廠方法讓類把實例化推遲到子類

所謂的決定並不是批模式允許子類本身在運行時做決定，而是指在編寫創建者類時，不需知道創建的產品是哪一下，選擇了使用

哪個子類，就決定了實際創建的產品是什么。

 

#region 工廠模式

    // 產品
    public abstract class Product
    {
        public string productName;
    }

    // 建造者
    //工廠方法是創建一個框架，讓子類決定要如何實現具體的產品
    public abstract class Creator
    {
        public Product FactoryMethod(string f_ProductType)
        {
            Product _product;
            _product=CreateProduct(f_ProductType);
　　　　　　　　//可對產品做其它的操作......
            return _product;
        }
        //讓子類去實現要生產什么產品
        public abstract Product CreateProduct(string f_Type);      

    }
    #region  產品
    public class OneProduct : Product
    {
        public OneProduct()
        {
            productName = "OneProduct";
        }
    }

    public class TwoProduct : Product
    {
        public TwoProduct()
        {
            productName = "TwoProduct";
        }
    }

    public class FirstProduct : Product
    {
        public FirstProduct()
        {
            productName = "My FirstProduct";
        }
    }

    public class SecondProduct : Product
    {
        public SecondProduct()
        {
            productName = "My SecondProduct";
        }
    }
    #endregion
    //第一個建造工廠
    public class OneCreator : Creator
    {
        public override Product CreateProduct(string f_Type)
        {
            switch (f_Type)
            {
                case "one":
                    return new OneProduct();                    
                case "two":
                    return new TwoProduct();                    
            }

            return null;
        }
    }
    //第二個建造工廠
    public class TwoCreator : Creator
    {
        public override Product CreateProduct(string f_Type)
        {
            switch (f_Type)
            {
                case "one":
                    return new FirstProduct();                    
                case "two":
                    return new SecondProduct();                    
            }
            return null;
        }
    }



    #endregion

static void Main(string[] args)
        {
           

            #region 工場模式
            
           
            
            //第一個工廠 兩種產品
            Creator _creator = new OneCreator();
            Product _product = _creator.FactoryMethod("one");
            Console.WriteLine(_product.productName);
            _product = _creator.FactoryMethod("two");
            Console.WriteLine(_product.productName);

            //第二個工廠  造另兩種產品

            Creator _tCreator = new TwoCreator();
            Product _tProduct = _tCreator.FactoryMethod("one");
            Console.WriteLine(_tProduct.productName);
            _tProduct = _tCreator.FactoryMethod("two");
            Console.WriteLine(_tProduct.productName);
            #endregion

            Console.ReadLine();
        }

讓我們來看一下依賴關系

我們會看到 Creator 和所有的產品（OneProduct、TwoProduct...）都依賴了Product.這是依賴倒置原則：要依賴抽象，不要依賴具體類

也就是說不能讓具體產品去依賴Creator，不管是產品還是Creator都應該依賴於抽象

就用這個原則我們要盡量做到 

1變量不可以持有具體類的引用（如果使用new就會有具體類的引用。你可以改用工廠來避開這樣的做法）

2不要讓類派生自具體類（派生自一個接口）

3不要覆蓋基類中已實現的方法

但在實際編程時不可能完全遵守這幾條，我們只要盡量做就可以了

 

 c++代碼 

product

#pragma once
#include <iostream>
#include <string>
using namespace std;

class Product
{
public:
    Product();
    virtual ~Product();
    
    string ProductName()
    {
        return m_rodutName;
    }
protected:
    string m_rodutName;

};

class OneProduct : public Product
{
public:
    OneProduct();
    virtual ~OneProduct();

};


class TwoProduct : public Product
{
public:
    TwoProduct();
    virtual ~TwoProduct();
};

#include "stdafx.h"
#include "Product.h"


Product::Product()
{

}

Product::~Product()
{

}


// One Product
OneProduct::OneProduct()
{
    m_rodutName = "One Prodect";
}

OneProduct::~OneProduct()
{

}

// TwoProduct

TwoProduct::TwoProduct()
{
    m_rodutName = "Two Prodect";
}

TwoProduct::~TwoProduct()
{

}

#pragma once

#include <iostream>
#include <string>

class Product;

class Creator
{
public:
    Creator();
    virtual ~Creator();

    Product* FactoryMehtod(const std::string& type);

    virtual Product* CreateProduct(const std::string& type) = 0;
};

class OneCreator : public Creator
{
    Product* CreateProduct(const std::string& type);
};

#include "stdafx.h"
#include "Creator.h"
#include "Product.h"

Creator::Creator()
{

}

Product* Creator::FactoryMehtod(const std::string& type)
{
    Product* product = CreateProduct(type);
    return product;
}

Creator::~Creator()
{

}


Product* OneCreator::CreateProduct(const std::string& type)
{
    if (type.compare("one")) {
        return new OneProduct();
    }
    else if (type.compare("two")) {
        return new TwoProduct();
    }
}

 調用

#include <iostream>
#include "Product.h"
#include "Creator.h"

int main()
{
    Creator *creator = new OneCreator();
    Product *pd = creator->CreateProduct("one");
    std::cout << pd->ProductName() << endl;
    delete pd;
    pd = creator->CreateProduct("two");
    std::cout << pd->ProductName() << endl;
    delete pd;
    delete creator;

}