设计模式 - 工厂模式

金陈

已于 2022-08-02 22:21:28 修改

阅读量138

点赞数

分类专栏：面经文章标签：设计模式

于 2022-08-02 22:16:15 首次发布

本文链接：https://blog.csdn.net/touchingnotyet/article/details/126131021

版权

面经专栏收录该内容

10 篇文章 1 订阅

订阅专栏

0.你是如何使用工厂模式的？

# 工厂模式流程
1. 创建一个工厂类的基类
2. 在这个基类中定义一个虚函数 -> 创建对象的方法，虚函数返回用于编解码的对象。
3. 创建子工厂类(编解码的基类有多少子类, 就创建多少个子工厂类)
	- 每个编解码的子类, 都对应一个工厂类
4. 在子工厂类中重写工厂类基类中的虚函数

// 两个编解码的子类
class RequestCodec : public Codec
class RespondCodec : public Codec
class TestCodec : public Codec	// 编解码响应数据

// 创建工厂类的基类
class BaseFactory
{
public:
    BaseFactory();
    ~BaseFactory;
    virtual Codec* createObject()
    {
        return NULL;
    }
}

// 工厂类子类
class RequestFactory : public BaseFactory
{
public:
    RequestFactory();
    ~RequestFactory;
    Codec* createObject()
    {
        return new RequestCodec;
    }
}

class RespondFactory : public BaseFactory
{
public:
    RespondFactory();
    ~RespondFactory;
    Codec* createObject()
    {
        return new RespondCodec;
    }
}

class TestFactory : public BaseFactory
{
public:
    TestFactory();
    ~TestFactory;
    Codec* createObject()
    {
        return new TestCodec;
    }
}

工厂模式使用

// 1. 创建工厂类对象
BaseFactory* fac = new RespondFactory;
// 2. 得到了编解码对象
Codec* c = fac->createObject();
// 3. 编码
string str = c->encodeMsg();

01.工厂模式的使用场景 or 优点

对象都需要创建，如果创建的时候直接new该对象，就会对该对象耦合严重，假如我们要更换对象，所有new对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则。如果我们使用工厂来生产对象，我们就只和工厂打交道就可以了，彻底和对象解耦，如果要更换对象，直接在工厂里更换该对象即可，达到了与对象解耦的目的；所以说，工厂模式最大的优点就是：解耦

1.简单工厂模式 – 只需要一个工厂类

1）简单工厂角色：把对象的创建放在一个工厂类中，通过参数的不同来创建不同的对象。

抽象产品：定义了产品的规范，描述了产品的主要特性和功能。(Coffee)
具体产品：实现或者继承抽象产品的子类(美式咖啡或拿铁咖啡)
具体工厂：提供了创建产品的方法，调用者通过该方法来获取产品。(生产咖啡的工厂)

2）优点：
封装了创建对象的过程，可以通过参数直接获取对象。把对象的创建和业务逻辑层分开，这样以后就避免了修改客户代码，如果要实现新产品直接修改工厂类，而不需要在原代码中修改，这样就降低了客户代码修改的可能性，更加容易扩展。

3）缺点：增加新产品时还是需要修改工厂类的代码，违背了“开闭原则”。

//抽象产品：咖啡类，抽象类
class Coffee {
public:
    Coffee();
    virtual ~Coffee();
    virtual string getName();
	//加糖
	void addSugar() {
		cout<<("加糖");
	}
	//加奶
	void addMilk() {
		cout<<("加奶");
	}
}

//具体产品，美式咖啡
class AmericanCoffee :public Coffee{
public:
    AmericanCoffee();
    virtual ~AmericanCoffee();
    string getName() {
		// TODO Auto-generated method stub
		return "美式咖啡";
	}
}

//具体产品，拿铁咖啡
class LatteCoffee  :public Coffee{
public:
    LatteCoffee ();
    virtual ~LatteCoffee ();
    string getName() {
		// TODO Auto-generated method stub
		return "拿铁咖啡";
	}
}

//工厂类
class SimpleCoffeeFactory {
public:
    Coffee* createCoffee(string type) {
		
		//声明Coffee类型变量，根据不同类型创建不同的Coffee子类对象
		Coffee* coffee=NULL;
		if("american"==(type)) {
			coffee=new AmericanCoffee();
		}else if("latte"==(type)) {
			coffee=new LatteCoffee();
		}else {
			throw new RuntimeException("对不起，你点的咖啡没有");
		}
		return coffee;
	}
};

class CoffeeStore {
public:
    Coffee* orderCoffee(String type) {
		//调用简单工厂来生产某种类型的咖啡
		SimpleCoffeeFactory* factory=new SimpleCoffeeFactory();
		Coffee* coffee=factory->createCoffee(type);
		//加配料
		coffee->addMilk();
		coffee->addSugar();
		
		return coffee;
	}
};

void main(String[] args) {
	//创建咖啡店类对象
	CoffeeStore* store=new CoffeeStore();
	Coffee* coffee=store->orderCoffee("latte");
	cout<<(coffee.getName());
}

2.工厂模式

1）工厂模式：每种产品由一种工厂来创建，一个工厂保存一个new

# 工厂模式流程
1. 创建一个工厂类的基类
2. 在这个基类中定义一个虚函数 -> 创建对象的方法
3. 创建子工厂类(编解码的基类有多少子类, 就创建多少个子工厂类)
	- 每个编解码的子类, 都对应一个工厂类
4. 在子工厂类中重写工厂类基类中的虚函数

工厂方法模式的主要角色：

抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法来创建产品。
具体工厂(ConcreteFactory)：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。

从以上的编写的代码可以看到，要增加产品类时也要相应地增加工厂类，不需要修改工厂类的代码了，这样就解决了简单工厂模式的缺点。

工厂方法模式是简单工厂模式的进一步抽象。由于使用了多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。

优点：

用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程；
在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类，无须对原工厂进行任何修改，满足开闭原则；

缺点：

每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度。

//抽象工厂:创建咖啡的抽象工厂
class CoffeeFactory {
 	CoffeeFactory();
    virtual ~CoffeeFactory();
	//创建咖啡的抽象方法
	virtual Coffee* createCoffee();
};

//具体工厂：拿铁咖啡工厂，专门生产拿铁咖啡
class LatteCoffeeFactory :public CoffeeFactory {
public:
    LatteCoffeeFactory();
    virtual ~LatteCoffeeFactory();
    Coffee* createCoffee() {
		// TODO Auto-generated method stub
		return new LatteCoffee();
	}
}

//具体工厂：美式咖啡工厂，专门生产美式咖啡
class AmericanCoffeeFactory:public CoffeeFactory {
public:
    AmericanCoffeeFactory();
    virtual ~AmericanCoffeeFactory();
    Coffee* createCoffee() {
		// TODO Auto-generated method stub
		return new AmericanCoffeeFactory();
	}
}

public class CoffeeStore {
private:
    CoffeeFactory* factory;
	
	void setFactory(CoffeeFactory* factory) {
		this.factory=factory;
	}
	//点咖啡的功能
public: 
    Coffee* orderCoffee() {
		Coffee* coffee=factory->createCoffee();
		//加配料
		coffee->addMilk();
		coffee->addSugar();
		return coffee;
	}
}

void main(String[] args) {
	//创建咖啡店对象
	CoffeeStore* store=new CoffeeStore();
		
	//创建对象
	CoffeeFactory* factory=new AmericanCoffeeFactory();
	store->setFactory(factory);
		
	//点咖啡
	Coffee* coffee=store->orderCoffee();
	cout<<(coffee->getName());
	}
}

3.抽象工厂模式

工厂方法模式只考虑生产同等级的产品，但是在现实生活中许多工厂是综合型的工厂，能生产多等级（种类）的产品，如电器厂既生产电视机又生产洗衣机或空调，大学既有软件专业又有生物专业等。

抽象工厂模式将考虑多等级产品的生产，将同一个具体工厂所生产的位于不同等级的一组产品称为一个产品族，下图所示横轴是产品等级，也就是同一类产品；纵轴是产品族，也就是同一品牌的产品，同一品牌的产品产自同一个工厂。

抽象工厂模式的主要角色如下：
抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法，可以创建多个不同等级的产品。
具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

抽象产品：咖啡

//咖啡类
class Coffee {
public:
    Coffee();
    virtual ~Coffee();
    virtual string getName();
	//加糖
	void addSugar() {
		cout<<("加糖");
	}
	//加奶
	void addMilk() {
		cout<<("加奶");
	}
}

//具体产品：美式咖啡
class AmericanCoffee :public Coffee{
public:
    string getName() {
		// TODO Auto-generated method stub
		return "美式咖啡";
	}
};

//具体产品：拿铁咖啡
class LatteCoffee :public Coffee{
public:
    string getName() {
		// TODO Auto-generated method stub
		return "拿铁咖啡";
	}
};

//抽象产品：甜品
class Dessert {
public:
	Dessert ();
    virtual ~Dessert ();
	virtual void show();
}

//具体产品：提拉米苏
class Trimisu :public Dessert{
public:
    void show() {
		// TODO Auto-generated method stub
		cout<<("提拉米苏");
	}
};

//具体产品：抹茶慕斯
class MatchaMouse :public Dessert{
public:
    void show() {
		// TODO Auto-generated method stub
		cout<<("抹茶慕斯");
	}
}

//抽象工厂：
class DessertFactory {
public:
    DessertFactory();
    virtual ~DessertFactory();
	//生产咖啡
	virtual Coffee* createCoffee();
	//生产甜品
	virtual Dessert* createDessert();
}

具体工厂：意大利风味工厂，生产提拉米苏，生产拿铁咖啡

/**
 * 意大利风味工厂
 * 生产提拉米苏
 * 生产拿铁咖啡
 * @author CharlieLiang
 *
 */
class ItalyDessertFactory :public DessertFactory{
public:
    Coffee* createCoffee() {
		// TODO Auto-generated method stub
		return new LatteCoffee();
	}
	Dessert* createDessert() {
		// TODO Auto-generated method stub
		return new Trimisu();
	}
}

具体工厂：美式风味工厂：生产美式咖啡、抹茶慕斯

/**
 * 美式风味工厂
 * 生产美式咖啡和抹茶慕斯
 * @author CharlieLiang
 *
 */
public class AmericanDessertFactory :public DessertFactory{
public:
    Coffee* createCoffee() {
		// TODO Auto-generated method stub
		return new AmericanCoffee();
	}
	Dessert* createDessert() {
		// TODO Auto-generated method stub
		return new MatchaMouse();
	}
}

抽象工厂模式客户端演示

/**
 * 抽象工厂客户端演示
 * @author CharlieLiang
 *
 */
void main(String[] args) {
		//创建意大利风味工厂
	DessertFactory factory=new ItalyDessertFactory();
		
	//获取拿铁咖啡和提拉米苏
	Coffee coffee=factory.createCoffee();
	Dessert trimisu=factory.createDessert();
		
	cout<<(coffee.getName());
	trimisu.show();
	}
}

如果要加同一个产品族的话，只需要再加一个对应的工厂类(法国风味工厂)即可，不需要修改其他的类。
优点：
当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
缺点：
当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。

4.2.4.4 使用场景

当需要创建的对象是一系列相互关联或相互依赖的产品族时，如电器工厂中的电视机、洗衣机、空调等。
系统中有多个产品族，但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。
系统中提供了产品的类库，且所有产品的接口相同，客户端不依赖产品实例的创建细节和内部结构。
如：输入法换皮肤，一整套一起换。生成不同操作系统的程序。