1、大话设计模式，简单工厂

1、通过设计模式，找到封装变化，对象间松散耦合，针对接口编程的感觉，设计易维护、易扩展、易复用、灵活性好的程序。

2、通过封装，继承，多态把程序的耦合度降低。把业务逻辑与界面逻辑分开，让它们之间的耦合度下降，使他们更容易维护和扩展。

3、示例代码

?

#include "iostream"

#include "string"

#include "vector"

//#include "functional"

//#include "algorithm"

using namespace std;

 

class Operation

{

public:

    Operation(){}

    Operation(double dNumberA1, double dNumberB1)

    {

        dNumberA = dNumberA1;

        dNumberB = dNumberB1;

        dResult = 0.0;

    }

    double GetNumberA()

    {

        return dNumberA;

    }

    void SetNumberA(double dTempA)

    {

        dNumberA = dTempA;

    }

    double GetNumberB()

    {

        return dNumberA;

    }

 

    void SetNumberB(double dTempB)

    {

        dNumberB = dTempB;

    }

 

    virtual double GetResult()

    {

        return dResult;

    }

protected:

    double dNumberA;

    double dNumberB;

    double dResult;

};

 

class OperationAdd:public Operation

{

public:

    OperationAdd(){}

    OperationAdd(double dNumberA, double dNumberB):Operation(dNumberA, dNumberB){}

    double GetResult()

    {

        return dResult = dNumberA + dNumberB;

    }

};

 

class OperationSub:public Operation

{

public:

    OperationSub(){}

    OperationSub(double dNumberA, double dNumberB):Operation(dNumberA, dNumberB){}

    double GetResult()

    {

        return dResult = dNumberA - dNumberB;

    }

};

 

class OperationMul:public Operation

{

public:

    OperationMul(){}

    OperationMul(double dNumberA, double dNumberB):Operation(dNumberA, dNumberB){}

    double GetResult()

    {

        return dResult = dNumberA * dNumberB;

    }

};

 

class OperationDiv:public Operation

{

public:

    OperationDiv(){}

    OperationDiv(double dNumberA, double dNumberB):Operation(dNumberA, dNumberB){}

    double GetResult()

    {

        if (dNumberB == 0)

            throw runtime_error("除数不能为");

        return dResult = dNumberA / dNumberB;

    }

};

 

class OperationFactory

{

public:

    OperationFactory(string strOperaKind)

    {

        if (strOperaKind == "+")

            pOpera = new OperationAdd();

        if (strOperaKind == "-")

            pOpera = new OperationSub();

        if (strOperaKind == "*")

            pOpera = new OperationMul();

        if (strOperaKind == "/")

            pOpera = new OperationDiv();   

    }

    Operation* GetOperation()

    {

        return pOpera;

    }

    ~OperationFactory()

    {

        if (pOpera)

        {

            delete pOpera;

            pOpera = NULL;

        }

    }

private:

    Operation *pOpera;

};

 

int main()

{

    cout << "Input two num and a operation(a number, opera, a number):" << endl;

    double dNumberA1, dNumberB1;

    string strOpera;

    cin >> dNumberA1 >> dNumberB1 >> strOpera;

     

    OperationFactory MyOperationFac(strOpera);

    Operation *MyOperation = MyOperationFac.GetOperation();

    MyOperation->SetNumberA(dNumberA1);

    MyOperation->SetNumberB(dNumberB1);

    cout << MyOperation->GetResult();

    return 1;

}

4、UML图

a）Class（类）：斜体显示的类名为抽象类，“+”为public，“-”为private，“#”为protected。第一行为类名；第二行为特性（字段或属性）；第三行为操作（方法或行为）。抽象类，类名用斜体字。

b）Interface（接口）：接口顶端有《interface》与类区别，或者是棒棒糖形式的标记。

c）继承：空心三角形+实线为继承关系。鸟继承动物的特点。

d）实现接口：空心三角形+虚线。如实现飞翔的接口。

e）当一个类需要知道另一个类时可以用关联（association）。用实线箭头。如企鹅与气候是关联关系，因为企鹅需要知道气候情况。

f）聚合关系（Aggregation）vs合成（Composition）：

    Aggregation为弱“拥有”关系，即：A对象可以包含B对象，但B对象不是A对象的一部分。A对象包含的每个个体可以脱离A对象独立存在。使用空心菱形+实线箭头表示。如雁群由大雁聚合。

    Composition为强“拥有”关系，即：B对象是A对象的一部分。具有相同的生命周期。使用实心菱形+实线箭头表示。如翅膀是鸟的组成部分。

    Aggregation和Composition可以有基数。

g）依赖关系（Dependency）：使用虚线箭头表示，指向依赖的对象。如动物依赖氧气，水。

5、由上可见，无论是什么关系，如关联，组合，聚合等，其也是通过面向对象语言中多态，抽象，继承来实现。而关联，组合，聚合等，尽管含义不同，在代码中多数是通过在一个对象中定义另外一个对象（或其引用、指针）来实现。

参考：

【1】UML图

http://my.chinaunix.net/space.php?uid=13830775&do=blog&id=97645