设计模式三（学习笔记）

对象创建模式：
通过“对象创建”模式绕开new，来避免对象创建（new）过程种所导致的紧耦合（以来具体类），从而支持对象创建的稳定。它是接口抽象之后的第一部工作
典型模式：Factory Method、Abstract Factory、Prototype、Builder

1。Factory Method（工厂方法模式）
动机：在软件系统中，经常面临着创建对象的工作；由于需求的变化，需要创建的对象的具体类型经常变化。
定义：定义一个用于创建对象的接口，让子类决定实例化哪一个类，Factory Method使得一个类的实例化延迟（目的：解耦，手段：虚函数）到子类。
总结：用于隔离类对象的使用者和具体类型之间的耦合关系。面对一个经常变化的具体类型，紧耦合关系（new）会导致软件的脆弱。通过面向对象的手法，将所要创建的具体对象工作延迟到子类，从而实现一种扩展（而非更改）的策略，较好的解决了这种紧耦合关系。其缺点在于要求创建方法/参数相同。
举个例子

class ISplitter//抽象基类
{
public:
	virtual void split() = 0;
	virtual ~ISplitter() {}
};

class SplitterFactory//工厂基类
{
public:
	virtual ISplitter* CreateSplitter() = 0;
	virtual ~SplitterFactory() {}
};

//具体类
class BinarySplitter :public ISplitter{
	//.........
};
class TxtSplitter :public ISplitter {
	//.......
};
class PictureSplitter :public ISplitter {
	//.......
};

//具体工厂
class BinarySplitterFactory :public SplitterFactory {
public:
	virtual ISplitter* CreateSplitter() {
		return new BinarySplitter();
	}
};

class TxtSplitterFactory :public SplitterFactory {
public:
	virtual ISplitter* CreateSplitter() {
		return new TxtSplitter();
	}
};
class PictureSplitterFactory :public SplitterFactory {
public:
	virtual ISplitter* CreateSplitter() {
		return new PictureSplitter();
	}
};

class MainForm :public Form//只依赖抽象类
{
	SplitterFactory* factory;//工厂

public:
	MainForm(SplitterFactory* f) :factory(f) {}

	void Button1_Click() {
		//ISplitter* splitter = new FileSplitter(filePath, number);//仍是细节依赖，依赖具体类

		ISplitter* splitter = factory->CreateSplitter();//多态new
		splitter->split();
	}
};

2. Abstract Factory（抽象工厂）
   动机： 在软件系统中，经常面临着“一系列相互依赖的对象”的创建工作；同时，由于需求的变化，往往存在更多系列对象的创建工作。
   定义：提供一个接口，让该接口负责创建一系列“相关或者相互依赖的对象”，无需指定它们具体的类。
   总结：如果没有应对“多系列对象构建”的需求变化，则没必要使用此模式，这时候使用简单的工厂模式完全可以。“系列对象”指的是在某一特定系列下的对象之间有相互依赖、或作用的关系。不同系列的对象之间不能相互依赖。其缺点在于难以应对“新对象”的需求变动。
   举个栗子

//数据库访问有关的基类
class IDBConnection {

};
class IDBCommand {

};
class IDataReader {

};
class IDBFactory {
public://具有相关性，放在一起
	virtual IDBConnection* CreateConnection() = 0;
	virtual IDBCommand* CreateCommand() = 0;
	virtual IDataReader* CreateReader() = 0;
};


//支持sql相关类
class SqlConnection :public IDBConnection {

};
class SqlCommand :public IDBCommand {

};
class SqlDataReader :public IDataReader {

};
class SqlFactory :public IDBFactory {
public:
	virtual IDBConnection* CreateConnection() {}
	virtual IDBCommand* CreateCommand() {}
	virtual IDataReader* CreateReader() {}
};

//支持Oracle类型
class OracleConnection :public IDBConnection {

};
class OracleCommand :public IDBCommand {

};
class OracleDataReader :public IDataReader {

};
class OracleFactory :public IDBFactory {
public:
	virtual IDBConnection* CreateConnection() {}
	virtual IDBCommand* CreateCommand() {}
	virtual IDataReader* CreateReader() {}
};

class EmployeeDA0 {
	IDBFactory* factory;
public:
	EmployeeDA0(IDBFactory* f):factory(f){}
	vector<EmployeeD0> GetEmployees() {
		IDBConnection* connection = factory->Create();
		connection->ConnectionString ("...");

		IDBCommand* command = factory->Create();
		command->CommandText ("...");
		command->SetConnection(connection);

		IDataReader* reader = command->CreateReader();//command里面创建Reader,关联性
		while (reader->Read()) {
		}
	}
};

3.Prototype（原型模式）
动机：在软件系统中，经常面临着“某些结构复杂的对象”的创建工作；由于需求的变化，这些对象经常面临这剧烈的变化，但是他们却拥有比较稳定一致的接口。
定义：使用原型实例指定创建对象的种类，然后通过拷贝这些原型来创建新的对象。
总结：此模式同样用于隔离类对象的使用者和具体类型（易变类）之间的耦合关系，它同样要求这些“易变类”拥有“稳定的接口”。此模式对于“如何创建易变类的实体对象”采用“原型克隆”的方法来做，他使得我们可以非常灵活地动态创建“拥有某些稳定接口”地新对象——所需工作仅仅是注册一个新类地对象（即原型），然后在任何需要的地方克隆。
举个例子

class ISplitter//抽象基类
{
public:
	virtual void split() = 0;
	virtual ISplitter* clone() = 0;//通过克隆自己创建对象
	virtual ~ISplitter() {}
};

//具体类
class BinarySplitter :public ISplitter{
public:
	virtual ISplitter* clone() {
		return new BinarySplitter(*this);//拷贝构造
	}
};
class TxtSplitter :public ISplitter {
public:
	virtual ISplitter* clone() {
		return new TxtSplitter(*this);
	}
};
class PictureSplitter :public ISplitter {
public:
	virtual ISplitter* clone() {
		return new PictureSplitter(*this);
	}
};

class MainForm :public Form
{
	ISplitter* prototype;//原型对象

public:
	MainForm(ISplitter* p) :prototype(p) {}

	void Button1_Click() {
		ISplitter* splitter = prototype->clone();//克隆原型
	}
};

4.Builder（构建器）
动机：在软件系统中，有时候面临着“一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临这剧烈的变化，但是将他们组合在一起的算法却相对稳定。
定义：将一个复杂对象的构建与其表示相分离，使得同样的构建过程（稳定）可以创建不同的表示（变化）。
总结：此模式主要用于“分步骤构建一个复杂的对象”。在这其中“分步骤”是一个稳定的算法，而复杂对象的各个部分则经常变化。变化点在哪里，封装在哪里——此模式主要在于应对“复杂对象各个部分”的频繁需求变动。其缺点在于难于应对“分步骤构建算法”的需求变动。
举个例子

class House {//各种部件
	//............
public:
	virtual void Part1() = 0;
};

class HouseBuilder {//构建
public:
	House* GetResult()
	{
		return pHouse;
	}
	virtual ~HouseBuilder(){}
protected:
	House* pHouse;
	virtual void BuildPart1() = 0;
	virtual void BuildPart2() = 0;
	virtual void BuildPart2() = 0;
	virtual void BuildPart2() = 0;
	virtual void BuildPart2() = 0;
};

class HouseDirector {//组装
public:
	HouseBuilder* pHouseBuilder;
	HouseDirector(HouseBuilder* h) :pHouseBuilder(h){}
	House* Construct() {
		pHouseBuilder->BuildPart1();
		for (int i = 0; i < 4; ++i)
		{
			pHouseBuilder->BuildPart2();
		}
		bool flag = pHouseBuilder->BuildPart3();
		if (flag) {
			pHouseBuilder->BuildPart4();
		}
		pHouseBuilder->BuildPart5();
		return pHouseBuilder->GetResult();
	}
};

class StoneHouseBuilder :public HouseBuilder {
public:
	StoneHouseBuilder()
	{
		pHouse = new StoneHouse();
	}
protected:
	virtual void BuildPart1() {
		pHouse->Part1()
	}
	virtual void BuildPart2() {}
	virtual void BuildPart3() {}
	virtual void BuildPart4() {}
	virtual void BuildPart5() {}
};

class StoneHouse :public House {
	//........
};