设计模式之工厂模式

背景

在我们写代码时，经常会遇到下面这种情况

class user {

	void create() {
		//当产品A，B变化成C,D需更改使用者类的代码，
		//导致使用者与具体类的紧耦合。
		productA *pA = new productA;
		productB *pB = new productB;
	}
};
class productA {
};
class productB {
};

更改1

首先想到的是将产品往上提出一个抽象产品基类，如下所示

class user {
	void create() {
		//仍与productA耦合，没有解决问题
		Iproduct *pA = new productA();
	}
};
class Iproduct {
	virtual void create() = 0;
	virtual ~Iproduct();
};
class productA :public Iproduct{
public:
	productA();
	virtual void create(){}
};

更改2

=号前面我们已经依赖于抽象，但=号后面我们无法实例化抽象，我们可以用一个三方类负责实例化
具体类型，三方类就叫工厂类

class user {
public:
	factory *fact;
	void create() {
		//user依赖factory,factory依赖productA，间接依赖，仍没有解决问题
		Iproduct *pA = fact->createProductA();
	}
};
class Iproduct {
	virtual void create() = 0;
	virtual ~Iproduct();
};
class productA :public Iproduct{
public:
	productA();
	virtual void create(){}
};

class factory {
public:
	Iproduct* createProductA() {
		return new productA;
	}
};

更改3

更改2仍没有解决问题，因此仍需要将工厂类设计为抽象

class user {
public:
	Ifactory *fact;//传参进去具体的工厂子类
	void create() {
		//=号前后都依赖于抽象，将类的实例化延迟到子类（运行时），而不是编译时
		Iproduct *pA = fact->createProduct();
	}
};
class Iproduct {
	virtual ~Iproduct();
};
class productA :public Iproduct{
public:
	productA();
};
class productB :public Iproduct {
public:
	productB();
};

class Ifactory {
public:
	virtual Iproduct* createProduct() = 0;
};

class factoryA :public Ifactory {
	Iproduct* createProduct() {
		return new productA;
	}
};

class factoryB :public Ifactory {
	Iproduct* createProduct() {
		return new productB;
	}
};

定义

定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使得一个类的实例化延迟。

要点总结

1工厂方法用于隔离类对象的使用者和具体类型的紧耦合关系，面对一个具体变化的类型，紧耦合关系会导致软件的脆弱。
2将创建对象的工作延迟到了子类，实现了一种扩展而非更改的策略。
3解决的是单个对象的需求变化，要求创建方法参数相同。