[设计模式C++]工厂模式

    工厂模式主要是为创建对象提供过渡接口,以便将创建对象的具体过程屏蔽隔离起来,达到提高灵活性的目的。
    工厂模式分为三类,文章会一一介绍。

1 简单工厂模式

1.1 概述

    简单工厂模式又称为静态工厂模式。重命名上就可以看出这个模式一定很简单。它存在的目的很简单:定义一个用于创建对象的借口

1.2 构建组成

  1. 工厂类角色:这是本模式的核心,含有一定的商业逻辑和判断逻辑。

  2. 抽象产 品角色:它一般是具体产品继承的父类或者实现的接口。

  3. 具体产品角色:工厂类所创建的对象就是此角色的实例。

在这里插入图片描述

在这里插入图片描述

1.3 代码实例

模拟工厂生产三种水果

# include<iostream>
using namespace std;

//抽象水果
class abstractFruit
{
public:
	virtual void show() = 0;

};
//苹果类
class Apple:public abstractFruit
{
public:
	void show()
	{
		cout<<"我是苹果!"<<endl;
	}
};
//香蕉
class Banana :public abstractFruit
{
public:
	void show()
	{
		cout << "我是香蕉!" << endl;
	}
};
//鸭梨
class Pear :public abstractFruit
{
public:
	void show()
	{
		cout << "我是鸭梨!" << endl;
	}
};
class FruitFactory
{
public:
	abstractFruit* CreateFruit(string flat)
	{
		if (flat == "Apple")
		{
			return new Apple;
		}
		else if (flat == "Banana")
		{
			return new Banana;
		}
		else if (flat == "Pear")
		{
			return new Pear;
		}
		else
		{
			cout<<"工厂内暂时未生产该类别"<<endl;
			return NULL;
		}
	}
};
# if 1
int main()
{
	FruitFactory* Factor1 = new FruitFactory;
	abstractFruit* apple= Factor1->CreateFruit("Apple");
	apple->show();
	abstractFruit* Banana = Factor1->CreateFruit("Banana");
	Banana->show();
	abstractFruit* Pear = Factor1->CreateFruit("Pear");
	Pear->show();
	delete(apple);
	delete(Banana);
	delete(Pear);

	return 0;
}
# endif

在这里插入图片描述

1.4 分析总结

    使用简单工厂模式后,程序更加符合现实中的情况:而且客户端免除了直接创建产品对象的责任。
    但从开闭原则分析,当我们增加一种水果的时候,只要符合抽象产品制定的合同,那么只要通知工厂类知道就可以被客户使用了。所以对产品部分来说,它符合开闭原则;但是工厂部分好像不太理想,因为每次增加一种水果,都要在工厂类中增加相应的业务逻辑或者判断逻,这显然是违背开闭原则的。可想而知对于新产品的加入,工厂类是很被动的。

2 工厂方法模式

2.1 概述

    工厂方法模式去掉了简单工厂模式中工厂方法的静态属性,使得它可以被子类继承。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。

2.2 构建组成

  1. 抽象工厂 角色:这是工厂方法模式的核心,它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。
  2. 具体工厂角色:它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
  3. 抽象产品角色:它是具体产品继承的父类或者是实现的接口。
  4. 具体产 品角色:具体工厂角色所创建的对象就是此角色的实例。

在这里插入图片描述

在这里插入图片描述

2.3 代码实例

# include<iostream>
using namespace std;
//抽象水果
class abstractFruit
{
public:
	virtual void show() = 0;

};
//苹果类
class Apple :public abstractFruit
{
public:
	void show()
	{
		cout << "我是苹果!" << endl;
	}
};
//香蕉
class Banana :public abstractFruit
{
public:
	void show()
	{
		cout << "我是香蕉!" << endl;
	}
};
//鸭梨
class Pear :public abstractFruit
{
public:
	void show()
	{
		cout << "我是鸭梨!" << endl;
	}
};
//抽象工厂
class AbstractFruitFactory 
{
public:
	virtual abstractFruit* GreateFruit() = 0;
};
//具体苹果厂
class AppleFactory :public AbstractFruitFactory
{
public:
	abstractFruit* GreateFruit()
	{
		return new Apple;
	}
};
//具体一个香蕉工厂
class BananaFactory :public AbstractFruitFactory
{
public:
	abstractFruit* GreateFruit()
	{
		return new Banana;
	}
};

//具体的鸭梨厂
class PearFactory :public AbstractFruitFactory
{
public:
	abstractFruit* GreateFruit()
	{
		return new Pear;
	}
};

int main()
{
	AbstractFruitFactory* Factory = nullptr;
	abstractFruit* Fruit = nullptr;
	//创建苹果厂
	Factory = new AppleFactory;
	Fruit=Factory->GreateFruit();
	Fruit->show();

	delete Fruit;
	delete Factory;
	//创建香蕉厂
	Factory = new BananaFactory;
	Fruit = Factory->GreateFruit();
	Fruit->show();

	delete Fruit;
	delete Factory;
	//创建鸭梨厂
	Factory = new PearFactory;
	Fruit = Factory->GreateFruit();
	Fruit->show();

	delete Fruit;
	delete Factory;

	return 0;
}

3 抽象工厂模式

3.1 概述

    抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口,无需指定它们具体的类

  1. 产品族:同一产地或者同一产商,功能不同

  2. 产品等级:功能不同,产地或者产商不同

  3. 抽象工厂针对的产品族 而不是产品等级结构

  4. 如果我增加一个水果。不符合开闭原则。

  5. 但是多几个工厂 就符合开闭原则

  6. 总结:对于产品族符合开闭原则 产品等级不符合开闭原则
    在这里插入图片描述

3.2 构建组成

和工厂方法一致

  1. 抽象工厂 角色:这是工厂方法模式的核心,它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。
  2. 具体工厂角色:它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
  3. 抽象产品角色:它是具体产品继承的父类或者是实现的接口。
  4. 具体产 品角色:具体工厂角色所创建的对象就是此角色的实例。

3.3 代码实例

# include<iostream>
using namespace std;
//抽象工厂针对的产品族 而不是产品等级结构
//产品族 同一个产地或者同一个厂商
//产品等级:功能相同 产地或者厂商不同
//如果我增加一个水果。不符合开闭原则。
//但是多几个工厂 就符合开闭原则 
//总结 对于产品族符合开闭原则  产品等级不符合开闭原则


//抽象苹果
class AbstractApple
{
public:
	virtual void show()= 0;
};
//中国苹果
class ChineseApple :public AbstractApple
{
public:
	void show()
	{
		cout << "中国苹果"<<endl;
	}
};

//美国苹果
class USAApple :public AbstractApple
{
public:
	void show()
	{
		cout << "美国苹果" << endl;
	}
};

//日本苹果
class JapanApple :public AbstractApple
{
public:
	void show()
	{
		cout << "日本苹果" << endl;
	}
};

//抽象香蕉
class AbstractBanana
{
public:
	virtual void show() = 0;
};
//中国香蕉
class ChineseBanana :public AbstractBanana
{
public:
	void show()
	{
		cout << "中国香蕉" << endl;
	}
};
//美国香蕉
class USABanana :public AbstractBanana
{
public:
	void show()
	{
		cout << "美国香蕉" << endl;
	}
};
//日本香蕉
class JapanBanana :public AbstractBanana
{
public:
	void show()
	{
		cout << "日本香蕉" << endl;
	}
};
//抽象工厂
class AbstractFactory
{
public:
	virtual AbstractApple* CreateApple() = 0;
	virtual AbstractBanana* CreateBanana() = 0;
};

//中国工厂
class ChineseFactor :public AbstractFactory
{
public:
	AbstractApple* CreateApple() 
	{
		return new ChineseApple;
	}
	AbstractBanana* CreateBanana()
	{
		return new ChineseBanana;
	}
};
//美国工厂
class USAFactor :public AbstractFactory
{
public:
	AbstractApple* CreateApple()
	{
		return new USAApple;
	}
	AbstractBanana* CreateBanana()
	{
		return new USABanana;
	}
};
//日本工厂
class JapanFactor :public AbstractFactory
{
public:
	AbstractApple* CreateApple()
	{
		return new JapanApple;
	}
	AbstractBanana* CreateBanana()
	{
		return new JapanBanana;
	}

};

int main()
{
	AbstractFactory* factory = NULL;
	AbstractApple* apple = NULL;
	AbstractBanana* banana = NULL;
	//中国工厂
	factory = new ChineseFactor;
	apple=factory->CreateApple();
	banana = factory->CreateBanana();
	apple->show();
	banana->show();
	delete(banana);
	delete(apple);
	delete(factory);
	//美国工厂
	factory = new USAFactor;
	apple = factory->CreateApple();
	banana = factory->CreateBanana();
	apple->show();
	banana->show();
	delete(banana);
	delete(apple);
	delete(factory);


	//日本工厂
	factory = new JapanFactor;
	apple = factory->CreateApple();
	banana = factory->CreateBanana();
	apple->show();
	banana->show();
	delete(banana);
	delete(apple);
	delete(factory);
}

4 总结

工厂模式也是比较常见,需要注意的是三种工厂模式的区别、使用场景和适用条件。

在这里插入图片描述

已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 像素格子 设计师:CSDN官方博客 返回首页