大话设计模式-简单工厂模式、工厂方法模式、抽象工厂模式

简单工厂模式

概念：简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。

适合应用于具有多个分支，不同的情况需要生成对应的类，将分支移到工厂类中，减少客户端的复杂度。但如果要新添加一个产品类的话，需要修改工厂类的代码。

 1 // OperationFactory.cpp : 定义控制台应用程序的入口点。
 2 //
 3 
 4 #include "stdafx.h"
 5 #include <iostream>
 6 #include <string>
 7 using namespace std;
 8 
 9 class Operation{
10 private:
11     int numberA;
12     int numberB;
13 public:
14     void setNumberA(int a){
15         this->numberA = a;
16     }
17     void setNumberB(int b){
18         this->numberB = b;
19     }
20     int getNumberA(){
21         return numberA;
22     }
23     int getNumberB(){
24         return numberB;
25     }
26     virtual int getResult()=0;
27 };
28 
29 class OperationAdd:public Operation{
30 public:
31     int getResult(){
32         return (getNumberA() + getNumberB());
33     }
34 };
35 class OperationSub:public Operation{
36 public:
37     int getResult(){
38         return (getNumberA() - getNumberB());
39     }
40 };
41 class OperationMul:public Operation{
42 public:
43     int getResult(){
44         return (getNumberA() * getNumberB());
45     }
46 };
47 class OperationDiv:public Operation{
48 public:
49     int getResult(){
50         return (getNumberA() / getNumberB());
51     }
52 };
53 
54 class OperationFactory{
55 public:
56      Operation* createOperation(char ch){
57         Operation *p = NULL;
58         switch(ch){
59         case '+':
60             p = new OperationAdd();
61             break;
62         case '-':
63             p = new OperationSub();
64             break;
65         case '*':
66             p = new OperationMul();
67             break;
68         case '/':
69             p = new OperationDiv();
70             break;
71         }
72         return p;
73     }
74      //单例模式
75      static OperationFactory & getInstance(){
76          static OperationFactory of;
77          return of;
78      }
79 };
80 int _tmain(int argc, _TCHAR* argv[])
81 {
82     Operation *p;
83     p = OperationFactory::getInstance().createOperation('+');
84     p->setNumberA(2);
85     p->setNumberB(3);
86     cout << p->getResult()<< endl;
87     return 0;
88 }

 简单工厂模式在遇到新的类添加时，需要对工厂类进行修改，这未被了开放-封闭原则。

工厂方法模式：

概念：定义一个用于创建对象的接口，让子类决定实例化那一个类。工厂方法使得一个类的实例化延迟到其子类。

工厂方法模式是简单工厂模式的进一步抽象和推广，使用了多态性，保持了简单工厂模式的有点，也克服简单工厂模式的缺点。但是每增加一个类，就要对应的增加该类的工厂类。

  1 // OperationFactory.cpp : 定义控制台应用程序的入口点。
  2 //
  3 
  4 #include "stdafx.h"
  5 #include <iostream>
  6 #include <string>
  7 using namespace std;
  8 
  9 class Operation{
 10 private:
 11     int numberA;
 12     int numberB;
 13 public:
 14     void setNumberA(int a){
 15         this->numberA = a;
 16     }
 17     void setNumberB(int b){
 18         this->numberB = b;
 19     }
 20     int getNumberA(){
 21         return numberA;
 22     }
 23     int getNumberB(){
 24         return numberB;
 25     }
 26     virtual int getResult()=0;
 27 };
 28 
 29 class OperationAdd:public Operation{
 30 public:
 31     int getResult(){
 32         return (getNumberA() + getNumberB());
 33     }
 34 };
 35 class OperationSub:public Operation{
 36 public:
 37     int getResult(){
 38         return (getNumberA() - getNumberB());
 39     }
 40 };
 41 class OperationMul:public Operation{
 42 public:
 43     int getResult(){
 44         return (getNumberA() * getNumberB());
 45     }
 46 };
 47 class OperationDiv:public Operation{
 48 public:
 49     int getResult(){
 50         return (getNumberA() / getNumberB());
 51     }
 52 };
 53 
 54 class IOperationFactory{
 55 public:
 56     virtual Operation * createOperation()=0;
 57 };
 58 class AddFactory:public IOperationFactory{
 59 
 60     Operation* createOperation(){
 61         return new OperationAdd();
 62     }
 63 };
 64 class SubFactory:public IOperationFactory{
 65     Operation* createOperation(){
 66         return new OperationSub();
 67     }
 68 };
 69 class MulFactory:public IOperationFactory{
 70     Operation* createOperation(){
 71         return new OperationMul();
 72     }
 73 };
 74 class DivFactory:public IOperationFactory{
 75     Operation* createOperation(){
 76         return new OperationDiv();
 77     }
 78 };
 79 //简单工厂模式
 80 class SimpleFactory{
 81 public:
 82     IOperationFactory *createOperationFactory(char ch){
 83         IOperationFactory *pf;
 84         switch (ch)
 85         {
 86         case '+': pf = new AddFactory();break;
 87         case '-': pf = new SubFactory();break;
 88         case '*': pf = new MulFactory();break;
 89         case '/': pf = new DivFactory();break;
 90         }
 91         return pf;
 92     }
 93     static SimpleFactory& createSimpleFactory(){
 94         static SimpleFactory sf;
 95         return sf;
 96     }
 97 };
 98 int _tmain(int argc, _TCHAR* argv[])
 99 {
100     IOperationFactory *pf = SimpleFactory::createSimpleFactory().createOperationFactory('+');
101     Operation *p = pf->createOperation();
102     p->setNumberA(2);
103     p->setNumberB(3);
104     cout << p->getResult()<< endl;
105     return 0;
106 }