一:简单工厂模式
简单工厂的UML图:
代码如下:
#include<iostream>
#include<string>
using std::cout;
using std::endl;
using std::cin;
using std::string;
//基类
class Operation
{
public:
Operation():m_numberA(0),m_numberB(0)
{
};
Operation(double numberA,double numberB):m_numberA(numberA),m_numberB(numberB)
{
};
double getA()
{
return m_numberA;
};
double getB()
{
return m_numberB;
};
void setA(double number)
{
m_numberA = number;
};
void setB(double number)
{
m_numberB = number;
};
virtual double GetResult()//多态性
{
return 0;
}
protected:
double m_numberA;
double m_numberB;
};
//加法类
class OperationAdd :public Operation //继承
{
public:
double GetResult()
{
double result = 0;
result = m_numberA + m_numberB;
return result;
}
};
//减法类
class OperationSub :public Operation
{
public:
double GetResult()
{
double result = 0;
result = m_numberA - m_numberB;
return result;
}
};
//乘法类
class OperationMul :public Operation
{
public:
double GetResult()
{
double result = 0;
result = m_numberA * m_numberB;
return result;
}
};
//除法类
class OperationDiv :public Operation
{
public:
double GetResult()
{
double result = 0;
if ( m_numberB == 0 )
throw "除数不能为0";
result = m_numberA / m_numberB;
return result;
}
};
//计算工厂设计模式
class OperationFactory
{
public:
static Operation* createOperate(char oper) //封装
{
Operation* myOper=NULL;
switch (oper)
{
case '+':
myOper=new OperationAdd();
break;
case '-':
myOper = new OperationSub();
break;
case '*':
myOper = new OperationMul();
break;
case '/':
myOper = new OperationDiv();
break;
default:
break;
};
return myOper;
}
};
void main()
{
int operaterA,operaterB;
cout<<"请输入数字A"<<endl;
cin>>operaterA;
cout<<"请输入数字B"<<endl;
cin>>operaterB;
Operation* op=OperationFactory::createOperate('*');
op->setA(operaterA);
op->setB(operaterB);
cout<<operaterA<<" * "<<operaterB<<" 的结果为: "<<endl;
cout<<op->GetResult()<<endl;
}
工厂方法的UML:
本次程序的UML:
代码实现如下:
#include<iostream>
#include<string>
using std::cout;
using std::endl;
using std::string;
class Operation
{
public:
Operation()
:m_numberA(0),m_numberB(0)
{
};
Operation(double numberA, double numberB)
:m_numberA(numberA),m_numberB(m_numberB)
{
};
double getA()
{
return m_numberA;
};
void setA(double number)
{
m_numberA = number;
};
double getB()
{
return m_numberB;
};
void setB(double number)
{
m_numberB = number;
};
virtual double GetResult()
{
return 0;
}
protected:
double m_numberA;
double m_numberB;
};
class OperationAdd :public Operation
{
public:
double GetResult()
{
double result = 0;
result = m_numberA + m_numberB;
return result;
}
};
class OperationSub :public Operation
{
public:
double GetResult()
{
double result = 0;
result = m_numberA - m_numberB;
return result;
}
};
class OperationMul :public Operation
{
public:
double GetResult()
{
double result = 0;
result = m_numberA * m_numberB;
return result;
}
};
class OperationDiv :public Operation
{
public:
double GetResult()
{
double result = 0;
if ( m_numberB == 0 )
throw "被除数不能为零";
result = m_numberA / m_numberB;
return result;
}
};
class IFactory
{
public:
virtual Operation* CreateOperation(void) = 0;
};
//加法工厂
class AddFactory :public IFactory
{
public:
Operation* CreateOperation(void)
{
return new OperationAdd();
};
};
//减法工厂
class SubFactory :public IFactory
{
public:
Operation* CreateOperation(void)
{
return new OperationSub();
};
};
//乘法工厂
class MulFactory :public IFactory
{
public:
Operation* CreateOperation(void)
{
return new OperationMul();
};
};
//除法工厂
class DivFactory :public IFactory
{
public:
Operation* CreateOperation(void)
{
return new OperationDiv();
};
};
int main()
{
IFactory* operFactory = new AddFactory();
Operation* oper = operFactory->CreateOperation();
oper->setA(1);
oper->setB(2);
double result = oper->GetResult();
cout<<result<<endl;
delete operFactory;
delete oper;
return 0;
}
1.简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断,根据客户端的选择条件动态实例化相关的类,对于客户端来说,去除了与具体产品的依赖。
2.工厂方法模式(Factory Method)定义一个用于创建对象的接口,让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到子类。
3.工厂方法模式的好处就是在扩展功能的时候,只要扩展了变化,不用修改现有的类了,也就完全符合了开放-封闭原则。
4.工厂方法把简单工厂的内部逻辑判断移到了客户端代码来进行。你想要加功能,搬来是改工厂类的,而现在是修改客户端。
5.工厂方法模式是简单工厂模式的进一步抽象和推广。由于使用了多态性,工厂方法模式保持了简单工厂模式的优点,而且克服了它的缺点。但缺点是由于每加一个产品,就需要加一个产品工厂的类,增加了额外的开发量。
2.工厂方法模式(Factory Method)定义一个用于创建对象的接口,让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到子类。
3.工厂方法模式的好处就是在扩展功能的时候,只要扩展了变化,不用修改现有的类了,也就完全符合了开放-封闭原则。
4.工厂方法把简单工厂的内部逻辑判断移到了客户端代码来进行。你想要加功能,搬来是改工厂类的,而现在是修改客户端。
5.工厂方法模式是简单工厂模式的进一步抽象和推广。由于使用了多态性,工厂方法模式保持了简单工厂模式的优点,而且克服了它的缺点。但缺点是由于每加一个产品,就需要加一个产品工厂的类,增加了额外的开发量。
抽象工厂的UML: