工厂方法模式

今天说一下工厂方法模式：

定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类

所谓的决定并不是批模式允许子类本身在运行时做决定，而是指在编写创建者类时，不需知道创建的产品是哪一下，选择了使用

哪个子类，就决定了实际创建的产品是什么。

#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 ProductOneProduct::OneProduct(){    m_rodutName = "One Prodect";}OneProduct::~OneProduct(){}// TwoProductTwoProduct::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;}