当前位置: 首页 > >

课题_设计模式:工厂方法模式

发布时间:

设计模式:工厂方法模式
今天说一下工厂方法模式: 定义了一个创建对象的接口,但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类 所谓的决定并不是批模式允许子类本身在运行时做决定,而是指在编写创建者类时,不需知道创建的产品是哪一下,选择了使用 哪个子类,就决定了实际创建的产品是什么。

1 #region 工厂模式 2 3 // 产品 4 public abstract class Product 5 { 6 public string productName; 7 } 8 9 // 建造者 10 //工厂方法是创建一个框架,让子类决定要如何实现具体的产品 11 public abstract class Creator 12 { 13 public Product FactoryMethod(string f_ProductType) 14 { 15 Product _product; 16 _product=CreateProduct(f_ProductType); //可对产品做其它的操作...... 17 return _product; 18 } 19 //让子类去实现要生产什么产品 20 public abstract Product CreateProduct(string f_Type); 21 22 } 23 #region 产品 24 public class OneProduct : Product 25 { 26 public OneProduct() 27 { 28 productName = "OneProduct"; 29 } 30 } 31

32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90

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

1 static void Main(string[] args) 2 { 3 4 5 #region 工场模式 6 7

8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

//第一个工厂 两种产品 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; }




友情链接: