设计模式之工厂方法模式
工厂方法模式，定义一个用于创建对象的接口，让子类决定实力化哪一个类。工厂方法使一个类的实例化延迟到其子类。其UML图如下：
这里要区分一下工厂方法模式与简单工厂模式的区别。简单工厂模式需要在工厂类中判断要生产什么类型的对象。工厂方法模式则把这部分工作交给了客户端。每一种类对象都有自己的工厂，客户端根据自己的不同需要生成不同工厂，然后在生产自己需要的对象。工厂方法模式相对简单工厂模式来说降低了类与客户端的耦合度。最重要的一点是当需要添加其他的类的时候不用修改原来的代码。只需用添加响应的工厂就行了和类就行了。这样做遵循了开放-封闭原则。而简单工厂模式实际是破坏了开放-封闭原则。
其代码如下：
1 // FactoryMethodModel.h文件
2 #pragma once
3 #include <iostream>
4 // 操作类
5 template<typename T>
6 class Operation
7 {
8 public:
9 Operation(const T &lpa, const T &rpa)
10 {
11 this->lpa = lpa;
12 this->rpa = rpa;
13 }
14 virtual T getResult() = 0;
15 protected:
16 T lpa, rpa;
17 };
18 //加法操作
19 template<typename T>
20 class AddOperation : public Operation<T>
21 {
22 public:
23 AddOperation(const T lpa, const T rpa) : Operation<T>(lpa, rpa)
24 {
25 ;
26 }
27 virtual T getResult()
28 {
29 return this->lpa + this->rpa;
30 }
31 };
32 // 减法操作
33 template<typename T>
34 class SubOperation : public Operation<T>
35 {
36 public:
37 SubOperation(const T lpa, const T rpa) : Operation<T>(lpa, rpa)
38 {
39 ;
40 }
41 virtual T getResult()
42 {
43 return this->lpa - this->rpa;
44 }
45 };
46 // 乘法操作
47 template<typename T>
48 class MulOperation : public Operation<T>
49 {
50 public:
51 MulOperation(const T lpa, const T rpa) : Operation<T>(lpa, rpa)
52 {
53 ;
54 }
55 virtual T getResult()
56 {
57 return this->lpa * this->rpa;
58 }
59 };
60 // 除法操作
61 template<typename T>
62 class DivOperation : public Operation<T>
63 {
64 public:
65 DivOperation(const T lpa, const T rpa) : Operation<T>(lpa, rpa)
66 {
67 ;
68 }
69 virtual T getResult()
70 {
71 if (0 == this->rpa)
72 {
73 std::cout << "除数不能为0" << std::endl;
74 return 0;
75 }
76 return this->lpa / this->rpa;
77 }
78 };
79 // 工厂类
80 template<typename T>
81 class Factory
82 {
83 public:
84 virtual Operation<T> * createObject(const T &lpa, const T &rpa) = 0;
85 };
86 // 加法工厂
87 template<typename T>
88 class AddFactory : public Factory<T>
89 {
90 public:
91 virtual Operation<T> * createObject(const T &lpa,const T &rpa)
92 {
93 return new AddOperation<T>(lpa, rpa);
94 }
95 };
96 // 减法工厂
97 template<typename T>
98 class SubFactory : public Factory<T>
99 {
100 public:
101 virtual Operation<T> * createObject(const T &lpa, const T &rpa)
102 {
103 return new SubOperation<T>(lpa, rpa);
104 }
105 };
106 // 乘法工厂
107 template<typename T>
108 class MulFactory : public Factory<T>
109 {
110 public:
111 virtual Operation<T> * createObject(const T &lpa, const T &rpa)
112 {
113 return new MulOperation<T>(lpa, rpa);
114 }
115 };
116 // 除法工厂
117 template<typename T>
118 class DivFactory : public Factory<T>
119 {
120 public:
121 virtual Operation<T> * createObject(const T &lpa,const T &rpa)
122 {
123 return new DivOperation<T>(lpa, rpa);
124 }
125 };
测是代码如下：
1 #include <iostream>
2 #include "FactoryMethodModel.h"
3
4 int main()
5 {
6 using namespace std;
7 // 工厂方法模式,与简单工厂模式的区别就是简单工厂模式中需要由工厂
8 // 来判断生成什么类型的Operation，而工厂方法模式则由客户端来判断
9 // 需要什么类型的操作则创建什么样的工厂，这样耦合度更低。添加类型
10 // 方法类型的时候不用修改原来的代码，遵从了开放-封闭原则。
11 double a = 1384.348, b = 109348.9785234;
12
13 Factory<double> *p = new AddFactory<double>;
14 Operation<double> * oper = p->createObject(a, b);
15 double d = oper->getResult();
16 cout << oper->getResult() << endl;
17 delete oper;
18 delete p;
19
20 p = new SubFactory<double>;
21 oper = p->createObject(a, b);
22 cout << oper->getResult() << endl;
23 delete oper;
24 delete p;
25
26 p = new MulFactory<double>;
27 oper = p->createObject(a, b);
28 cout << oper->getResult() << endl;
29 delete oper;
30 delete p;
31
32 p = new DivFactory<double>;
33 oper = p->createObject(a, b);
34 cout << oper->getResult() << endl;
35 delete oper;
36 delete p;
37
38 getchar();
39 return 0;
40 }
测试结果如下图：
