设计模式--工厂模式

工厂：根据具体产品参数来创建实体抽象产品：还有产品的基类以及创建方法具体产品：提供产品参数， 1.2 代码实现

class AbsProduct//抽象产品类
{
    public:
    //具体实现方法
};
// 具体产品（可定义多个，继承基类产品）
class realProduct :public AbsProduct
{
  public:
  //具体实现方法
};

class A :public AbsProduct
{
  public:
  //具体实现方法
};

class B :public AbsProduct
{
  public:
  //具体实现方法
};
class factory
{
   public :
        AbsProduct create(string product_name)
        {
           AbsProduct pro=NULL;
           if(product_name=="A")
           {
              pro=new A();
           }
           else if(product_name=="B")
           {
              pro=new B();
           }
        }
}

工厂：工厂负责生产产品
抽象产品：定义一个鞋子的基类
具体产品：定义各种品牌球鞋，例如耐克，阿迪，李宁

文件名：factory.h

产品抽象类

#pragma once
#include
#include
//抽象产品类AbstractProduct
using namespace std;
class AbstractSportProduct
{
public:
	AbstractSportProduct() {

	}
	//抽象方法：
	virtual void printName() {};
	virtual void play() {};
};

具体产品类

class LiNing :public AbsProduct
{
    public:
	LiNing() {
		
		
	}
	~LiNing()
	{
		printf("LINING-GGn");
	}
	void printName() {
		std::cout << "李宁" << std::endl;
	}
	void show()
	{
		printf("一切皆有可能n");
	}
};

class NIKE :public AbsProduct
{
public:
	NIKE() {
		prtintName();

	}
	~NIKE()
	{
		printf(" NIKE -GGn");
	}
	void printName() {
		printf(" NIKE n");
	}
	void show()
	{
		printf("to be number 1n");
	}
};

class ADIDAS :public AbsProduct
{
public:
	ADIDAS() {
		prtintName();

	}
	~ADIDAS()
	{
		printf(" ADIDAS -GGn");
	}
	void printName() {
		printf(" ADIDAS n");
	}
	void show()
	{
		printf("阿迪牛逼n");
	}
};

工厂类

class Factory
{
public:
	AbsProduct *getSportProduct(string productName)
	{
		AbsProduct *pro = NULL;
		if (productName == "LiNing") {
			pro = new LiNing();
		}
		else if (productName == "NIKE") {
			pro = new NIKE();
		}
		else if (productName == "ADIDAS") {
			pro = new ADIDAS();
		}
		return pro;
	}
};

主文件：

#include 
#include"factory.h"
#include
using namespace std;

int main()
{
	printf("简单工厂模式n");

	//定义工厂类对象
	Factory *fac = new Factory();
	
	AbsProduct *LiNing_product = NULL;
	LiNing_product = fac->getSportProduct("LiNing");
	if (LiNing_product)
	{
		
		LiNing_product->prtintName();
		LiNing_product->show();
		LiNing_product->~AbsProduct();
	}

	AbsProduct *NIKE_product = NULL;
	NIKE_product = fac->getSportProduct("NIKE");
	if (NIKE_product)
	{


		NIKE_product->show();
		NIKE_product->~AbsProduct();
		NIKE_product =NULL;
	}

	AbsProduct *ADI_product = NULL;
	ADI_product = fac->getSportProduct("ADIDAS");
	if (ADI_product)
	{
		ADI_product->show();
		ADI_product->~AbsProduct();
		ADI_product = NULL;
	}

    
	system("pause");
	return 0;
}

运行结果：

优点：
工厂方法模式抽象出了工厂类，提供创建具体产品的接口，交由子类去实现。
工厂方法模式的应用并不只是为了封装具体产品对象的创建，而是要把具体产品对象的创建放到具体工厂类实现。
缺点：
在新增生产线时，违反了开闭规则（对外拓展开放，对内修改关闭）

抽象工厂：提供工厂类的基类，提供工厂类的公共方法具体工厂：生产具体产品抽象产品：产品的基类以及创建方法具体产品：提供产品参数， 2.2 代码实现

抽象工厂
定义生产方法，纯虚函数

class AbstractFactory
{
public:
	virtual AbstractProduct *getProduct() = 0;//函数类型为纯虚函数
};

具体工厂
具体生产方法

class Factory_A :public AbstractFactory
{
public:
	Factory_A() {
		
	}
	AbstractProduct *getProduct() {
		printf("Product_A");
		return new Product_A();
	}
};

class Factory_B :public AbstractFactory
{
public:
	Factory_B() {
		
	}
	AbstractProduct *getProduct() {
		printf("Product_B");
		return new Product_B();
	}
};

抽象产品
产品的基类以及创建方法

class AbstractProduct
{
public:
	AbstractProduct() {

	}
	//抽象方法：
	void a() {};
	void b() {};
};

具体产品

class Product_A :public AbstractProduct
{
public:
	Product_A() {
		
	}
	//具体实现方法
	void a() {
		
	}
	void b() {
		
	}
};
class Product_B :public AbstractProduct
{
public:
	Product_B() {
		
	}
	//具体实现方法
	void a() {
		
	}
	void b() {
		
	}
};

factory.h

#pragma once
#include
#include
using namespace std;

//抽象产品类AbstractProduct
class AbstractSportProduct
{
public:
	AbstractSportProduct() {

	}
	//抽象方法：
	virtual void printName() {};
	virtual void play() {};
};
//具体产品类Basketball
class Basketball :public AbstractSportProduct
{
public:
	Basketball() {
		printName();
	
	}
	//具体实现方法
	void printName() {
		printf("Get Basketballn");
	}
	void play() {
		printf("Play Basketballnn");
	}
};

//具体产品类Football
class Football :public AbstractSportProduct
{
public:
	Football() {
		printName();
		
	}
	//具体实现方法
	void printName() {
		printf("Get Footballn");
	}
	void play() {
		printf("Play Footballnn");
	}
};

//具体产品类Volleyball
class Volleyball :public AbstractSportProduct
{
public:
	Volleyball() {
		printName();
	}
	//具体实现方法
	void printName() {
		printf("Get Volleyballn");
	}
	void play() {
		printf("Play Volleyballnn");
	}
};
//抽象工厂类
class AbstractFactory
{
public:
	virtual AbstractSportProduct *getSportProduct() = 0;
};

//具体工厂类BasketballFactory
class BasketballFactory :public AbstractFactory
{
public:
	BasketballFactory() {
		printf("BasketballFactoryn");
	}
	AbstractSportProduct *getSportProduct() {
		printf("basketball");
		return new Basketball();
	}
};

//具体工厂类FootballFactory
class FootballFactory :public AbstractFactory
{
public:
	FootballFactory() {
		printf("FootballFactoryn");
	}
	AbstractSportProduct *getSportProduct() {
		return new Football();
	}
};

//具体工厂类VolleyballFactory
class VolleyballFactory :public AbstractFactory
{
public:
	VolleyballFactory() {
		printf("VolleyballFactoryn");
	}
	AbstractSportProduct *getSportProduct() {
		return new Volleyball();
	}
};

main.cpp

#include 
#include "factory.h"
using namespace std;

int main()
{
	printf("工厂方法模式n");

	//定义工厂类对象和产品类对象
	AbstractFactory *fac = NULL;
	AbstractSportProduct *product = NULL;

	fac = new BasketballFactory();
	product = fac->getSportProduct();
	product->play(); 



	fac = new FootballFactory();
	product = fac->getSportProduct();
	product->play();



	fac = new VolleyballFactory();
	product = fac->getSportProduct();
	product->play();


	system("pause");
	return 0;
}

抽象工厂类：工厂方法模式的核心类，提供创建具体产品的接口，由具体工厂类实现。

具体工厂类：继承于抽象工厂，实现创建对应具体产品对象的方式。

抽象产品类：它是具体产品继承的父类（基类）。

具体产品类：具体工厂所创建的对象，就是此类。

Factory.h

#pragma once
#include
#include
using namespace std;
class Clothe
{
public:
	virtual void PrintName() = 0;
	virtual void Show() = 0;
	virtual ~Clothe() {}
};

// 耐克衣服
class NiKeClothe : public Clothe
{
public:
	NiKeClothe()
	{
		PrintName();
	}
	void Show()
	{
		std::cout << "我是耐克衣服，时尚我最在行！" << std::endl;
	}
	void PrintName()
	{
		std::cout << "耐克衣服" << std::endl;
	}
	~NiKeClothe()
	{
		std::cout << "耐克衣服GG" << std::endl;
	}
};

// 基类 鞋子
class Shoes
{
public:
	virtual void PrintName() = 0;
	virtual void Show() = 0;
	virtual ~Shoes() {}
};

// 耐克鞋子
class NiKeShoes : public Shoes
{
public:
	NiKeShoes()
	{
		PrintName();
	}
	void Show()
	{
		std::cout << "我是耐克球鞋，让你酷起来！" << std::endl;
	}
	void PrintName()
	{
		std::cout << "耐克球鞋" << std::endl;
	}
	~NiKeShoes()
	{
		std::cout << "耐克球鞋GG" << std::endl;
	}
};
// 总厂
class Factory
{
public:
	virtual Shoes *CreateShoes() = 0;
	virtual Clothe *CreateClothe() = 0;
	virtual ~Factory() {}
};

// 耐克生产者/生产链
class NiKeProducer : public Factory
{
public:
	NiKeProducer()
	{
		std::cout << "耐克好起来啦！！" << std::endl;
	}
	Shoes *CreateShoes()
	{
		return new NiKeShoes();
	}

	Clothe *CreateClothe()
	{
		return new NiKeClothe();
	}
	~NiKeProducer()
	{
		std::cout << "耐克不行啦！！" << std::endl;
	}
};

优点：满足了开闭原则
缺点：增加新产品的话代码量较大