网站建设费是/推广引流平台app大全

之前写了

 设计模式系列目录

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

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

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

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

 

#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;}