设计模式——工厂模式

一、概述

工厂模式分为三种形式：

简单工厂模式
工厂方法模式
抽象工厂模式

二、简单工厂模式

1.定义：

简单工厂模式又称为静态工厂方法模式，它属于类创建型模式，在简单工厂模式中，可以根据参数的不同返回不同的实例，简单工厂模式专门定义了一个类来负责创建其他类的实例，被创建的实例通常都是具有共同的父类。

2.简单工厂模式的类图

3.具体代码实现

（1）首先创建一个抽象的产品类；
（2）然后根据需要生产的产品，分别创建具体的类别，均继承自抽象产品类；
（3）创建工厂：工厂决定创建哪个类的实例。

//简单工厂模式
#include<iostream>
using namespace std;

class absdtrctproduct {
public:
	virtual void make() {};
};
class productA :public absdtrctproduct {
public:
	productA() {}
	virtual void make() {
		cout << "make A" << endl;
	}
};
class productB :public absdtrctproduct {
public:
	productB() {};
	virtual void make() {
		cout << "make B" << endl;
	}
};
class Factory {
public:
	static absdtrctproduct * makeAB(string chose) {
		if (chose == "huawei") {
			return new productA();
		}
		else if (chose == "iphone") {
			return new productB();
		}
		else {
			return nullptr;
		}
	}
};
int main() {
	absdtrctproduct* p = Factory::makeAB("huawei");
	p->make();
	p = Factory::makeAB("iphone");
	p->make();
	p = Factory::makeAB("iphone");
	p->make();
	return 0;
}

4.优缺点

优点：
实现对象的创建和使用的分离，创建完全交给专门的工厂负责，客服端只需要知道输入需要生成的东西即可。
缺点：
不够灵活，若新增一个产品，就需要修改工厂类，即判断逻辑，若是产品过多，则会导致逻辑非常复杂，违反了开闭原则。

三、工厂方法模式

1.定义

相较于简单工厂模式，工厂方法模式增加了一个用于创建抽象工厂的接口，让其子类决定实例化哪个类，使得一个类的实例化延迟到其子类。

2.工厂方法的类图

含有四个类：
抽象的工厂类
具体的工厂类
抽象的产品类
具体的产品类

3.具体代码实现

（1）首先创建一个抽象的产品类
（2）然后定义该抽象产品类的具体子类
（3）然后创建抽象工厂类
（4）最后创建子类工厂类

//工厂方法模式
#include<iostream>
#include<string>
using namespace std;

class absdtrctproduct {
public:
	virtual void make() {};
};
class productA :public absdtrctproduct {
public:
	productA() {}
	virtual void make() {
		cout << "make A" << endl;
	}
};
class productB :public absdtrctproduct {
public:
	productB() {};
	virtual void make() {
		cout << "make B" << endl;
	}
};
class abstractfactory {
public:
	virtual absdtrctproduct* makeAB() { return nullptr; }
};
class FactoryA:public abstractfactory {
public:
	FactoryA() {}
	virtual absdtrctproduct* makeAB() {
		return new productA();
	}
};
class FactoryB :public abstractfactory {
public:
	FactoryB() {};
	virtual absdtrctproduct* makeAB() {
		return new productB();
	}
};
int main() {
	FactoryA* p_A = new FactoryA();
	absdtrctproduct* p = p_A->makeAB();
	p->make();
	FactoryB* p_B = new FactoryB();
	p = p_B->makeAB();
	p->make();
	return 0;
}

4.特点

当需要再生产一个新的产品时，只需要再增加一个工厂类，不需要再对抽象工厂类进行修改，符合开闭原则

四、抽象工厂模式

1.特点

在工厂方法模式中，每个工厂只生产一个产品，而在抽象工厂模式下，一个工厂可以生产多个产品。
但是若要在原来的基础上工厂再增加生产其它产品，则需要对工厂的代码进行修改，违反了开闭原则。

2.具体代码实现

//抽象工厂模式
#include<iostream>
using namespace std;

class product_phone {
public:
	virtual void makephone() {}
};
class huawei_product :public product_phone {
public:
	huawei_product() {}
	virtual void makephone() {
		cout << "制造了华为手机" << endl;
	}
};
class vivo_product :public product_phone {
public:
	vivo_product() {}
	virtual void makephone() {
		cout << "制造了vivo手机" << endl;
	}
};
class product_mask {
public:
	product_mask() {}
	virtual void makemask(){}
};
class N95_product :public product_mask {
public:
	N95_product() {}
	virtual void makemask() {
		cout << "制造N95口罩" << endl;
	}
};
class doctor_product :public product_mask {
public:
	doctor_product(){}
	virtual void makemask() {
		cout << "制造医用外科口罩" << endl;
	}
};
class abstractfactory {
public:
	virtual product_phone* makeone() = 0;
	virtual product_mask* maketwo() = 0;
};
class FactoryA:public abstractfactory {
public:
	FactoryA() {}
	virtual product_phone* makeone() {
		return new huawei_product();
	}
	virtual product_mask* maketwo() {
		return new N95_product();
	}
};
class FactoryB :public abstractfactory {
public:
	FactoryB() {}
	virtual product_phone* makeone() {
		return new vivo_product();
	}
	virtual product_mask* maketwo() {
		return new doctor_product();
	}
};
int main() {
	FactoryA* p_A1 = new FactoryA();
	product_phone* p_1 = p_A1->makeone();
	p_1->makephone();
	FactoryA* p_A2 = new FactoryA();
	product_mask* p_2 = p_A2->maketwo();
	p_2->makemask();
	return 0;
}