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