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