简单工厂与策略模式

时间:2022-07-03 21:58:51

简单工厂模式

       专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类。它又称为静态工厂方法模式,属于类的创建型模式。简单工厂模式的实质是由一个工厂类根据传入的参数,动态决定应该创建哪一个产品类(这些产品类继承自一个父类或接口)的实例。

 

该模式中包含的角色及其职责:

1、工厂(Creator)角色

     简单工厂模式的核心,它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用,创建所需的产品对象。

2、抽象(Product)角色

  简单工厂模式所创建的所有对象的父类,它负责描述所有实例所共有的公共接口。

3、具体产品(Concrete Product)角色

 

简单工厂模式的特点:

     简单工厂模式的创建目标,所有创建的对象都是充当这个角色的某个具体类的实例。不难发现,简单工厂模式的缺点也正体现在其工厂类上,由于工厂类集中了所有实例的创建逻辑,所以“高内聚”方面做的并不好。另外,当系统中的具体产品类不断增多时,可能会出现要求工厂类也要做相应的修改,扩展性并不很好。

 

UML:

 简单工厂与策略模式

 

 

策略模式

        定义一系列的算法,把他们一个个封装起来,并且使它们可以相互替换。策略模式让算法可以独立于使用它的客户而变化。

适用性:

1、许多相关的类仅仅是行为有异。“策略”提供了一种用多个行为中的一个行为来配置一个类的方法。

2、需要使用一个算法的不同变体。例如:你可能会定义一些反应不同的空间、时间权衡的算法。当这些变体为一个算法的类层次时,可以用本模式。

3、算法使用客户不应该知道的数据。可适用策略模式避免暴露复杂、与算法相关的数据结构。

4、一个类定义了多种行为,并且这些行为在这个类的操作中以多个条件语句的形式出现。

参与者:

1、Strategy策略

      定义所以支持的算法的公共接口。

2、ConcreteStrategy具体策略

      以strategy接口实现的具体算法。

3、Context

      a.用一个ConcreteStrategy对象来配置。

      b.维护一个Strategy对象的引用。

      c.可定义一个接口来让Strategy访问它的数据。

 

UML:

简单工厂与策略模式 

 

 

简单工厂模式与策略模式的差异:

1、用途不一样 
       工厂是创建型模式,它的作用就是创建对象; 
       策略是行为型模式,它的作用是让一个对象在许多行为中选择一种行为;

2、关注点不一样 
       一个关注对象创建 
       一个关注行为的封装

3、解决不同的问题 

     工厂模式是创建型的设计模式,它接受指令,创建出符合要求的实例;它主要解决的是资源的统一分发,将对象的创建完全独立出来,让对象的创建和具体的使用客户无关。主要应用在多数据库选择,类库文件加载等。 
    策略模式是将不同的算法封装成一个对象,这些不同的算法从一个抽象类或者一个接口中派生出来,客户端持有一个抽象的策略的引用,这样客户端就能动态的切换不同的策略。策略模式让策略的变化独立于使用策略的客户。

 

代码:用简单方法实现两个数基本的算术运算!

定义一个基类

class Operation{
public:
Operation(
double num1 = 0, double num2 = 0)
{
mNum1
= num1;
mNum2
= num2;
}
virtual void setNum1(double num)
{
mNum1
= num;
}
virtual double getNum1()
{
return mNum1;
}
virtual void setNum2(double num)
{
mNum2
= num;
}
virtual double getNum2()
{
return mNum2;
}
virtual double getResult()
{
return 0;
}
private:
double mNum1;
double mNum2;
};

定义具体的运算类:

class OperationAdd:public Operation{
public:
OperationAdd(
double num1 = 0, double num2 = 0):Operation(num1, num2){}

virtual double getResult();
};

class OperationSub: public Operation
{
public:
OperationSub(
double num1 = 0, double num2 = 0):Operation(num1, num2){}

virtual double getResult();
};

class OperationMul:public Operation
{
public:
OperationMul(
double num1 = 0, double num2 = 0):Operation(num1, num2){}

virtual double getResult();
private:

};

class OperationDiv:public Operation{
public:
OperationDiv(
double num1 = 0, double num2 = 0):Operation(num1, num2){}

virtual double getResult();
};

运算方法具体实现:

double OperationAdd::getResult()
{
return getNum1() + getNum2();
}

double OperationSub::getResult()
{
return getNum1() - getNum2();
}

double OperationMul::getResult()
{
return getNum1() * getNum2();
}

double OperationDiv::getResult()
{
double divisor = getNum2();
if(divisor < 0.000001 && divisor > -0.000001)
{
return 0;
}
else
{
return getNum1() / getNum2();
}
}

实现简单工厂方法:

Operation* OperationFactory(char ch)
{
switch (ch)
{
case '+':
return new OperationAdd();
break;
case '-':
return new OperationSub();
break;
case '*':
return new OperationMul();
break;
case '/':
return new OperationDiv();
break;
default:
return new Operation();
break;
}
}

客户端代码

    while(1)
{
cin
>>num1;
cin.clear();
cin
>>ch;
cin.clear();
cin
>>num2;
cin.clear();
cin.ignore(std::numeric_limits
<std::streamsize>::max(), '\n');
Operation
* pOper = OperationFactory(ch);
pOper
->setNum1(num1);
pOper
->setNum2(num2);
cout
<<num1<<ch<<num2<<"="<<pOper->getResult()<<endl;
}

 

修改:计算数A和数B不同运算的结果。

简单工厂实现:

        int a = 22, b = 2;
Operation
* p = OperationFactory('+');
p
->setNum1(a);
p
->setNum2(b);
cout
<<p->getResult()<<endl;

p
= OperationFactory('-');
p
->setNum1(a);
p
->setNum2(b);
cout
<<p->getResult()<<endl;

p
= OperationFactory('*');
p
->setNum1(a);
p
->setNum2(b);
cout
<<p->getResult()<<endl;

p
= OperationFactory('/');
p
->setNum1(a);
p
->setNum2(b);
cout
<<p->getResult()<<endl;

策略模式实现:

把题目理解成通过加、减、乘、除 四中策略实现对A、B的运算!

增加类:Calculate

class Calculate{
public:
Calculate(Operation
* pOperation = OperationFactory('+')){mpOprt = pOperation;}

void setOperation(char ch)
{
mpOprt
= OperationFactory(ch);
}

void setNum1(double num1)
{
mpOprt
->setNum1(num1);
}

void setNum2(double num2)
{
mpOprt
->setNum2(num2);
}

double getResult()
{
return mpOprt->getResult();
}

private:
Operation
* mpOprt;
};

则客户端代码:

    int a = 22, b = 2;
Calculate oneCal;
oneCal.setNum1(a);
oneCal.setNum2(b);
cout
<<oneCal.getResult()<<endl;

oneCal.setOperation(
'-');
oneCal.setNum1(a);
oneCal.setNum2(b);
cout
<<oneCal.getResult()<<endl;

oneCal.setOperation(
'*');
oneCal.setNum1(a);
oneCal.setNum2(b);
cout
<<oneCal.getResult()<<endl;

oneCal.setOperation(
'/');
oneCal.setNum1(a);
oneCal.setNum2(b);
cout
<<oneCal.getResult()<<endl;

与简单工厂的实现相比较,策略模式客户端只需要对一个对象进行操作,并没有涉及到具体的策略实现类,使运算算法与客户端策底的分离。

而且策略模式更方便不同策略的切换!