抽象工厂模式

工厂模式：只能生产一个产品(单一产品，具体什么工厂就生产什么产品)  https://blog.csdn.net/jadeshu/article/details/23215933

 

抽象工厂：可以生产一个产品族(里面有很多产品组成)

 

C++代码：

#include <string>
#include <iostream>
using namespace std;
// 抽象工厂
// ---1.抽象工厂能生产一系统产品

// 产品基类A
class ProductA
{
public:
	virtual void Show() = 0;
};

// 具体产品A1
class ProductA1 : public ProductA
{ 
public:
	void Show() override
	{
		cout << "I'm ProductA1" << endl;
	}

};

// 具体产品A2
class ProductA2 : public ProductA
{ 
public:
	void Show() override
	{
		cout << "I'm ProductA2" << endl;
	}
};

// 产品基类B
class ProductB
{
public:
	virtual void Show() = 0;
};

// 具体产品B1
class ProductB1 : public ProductB
{
public:
	void Show() override
	{
		cout << "I'm ProductB1" << endl;
	}

};

// 具体产品B2
class ProductB2 : public ProductB
{
public:
	void Show() override
	{
		cout << "I'm ProductB2" << endl;
	}
};

// 抽象工厂基类(具备能生产产品A和产品B两种产品的能力)
class AbstractFactory
{
public:
	virtual ProductA* createProductA() = 0;
	virtual ProductB* createProductB() = 0;
};

// 工厂1(能生产产品A和产品B的具体产品)
class Factory1 : public AbstractFactory
{
public:
	ProductA* createProductA() override
	{
		return new ProductA1();
	}
	ProductB* createProductB() override
	{
		return new ProductB1();
	}
};

// 工厂2(能生产产品A和产品B的具体产品)
class Factory2 : public AbstractFactory
{
public:
	ProductA* createProductA() override
	{
		return new ProductA2();
	}
	ProductB* createProductB() override
	{
		return new ProductB2();
	}
};


int main()
{
	AbstractFactory *factoryObj1 = new Factory1();
	ProductA *productObjA1 = factoryObj1->createProductA();
	ProductB *productObjB1 = factoryObj1->createProductB();

	productObjA1->Show();
	productObjB1->Show();

	AbstractFactory *factoryObj2 = new Factory2();
	ProductA *productObjA2 = factoryObj2->createProductA();
	ProductB *productObjB2 = factoryObj2->createProductB();

	productObjA2->Show();
	productObjB2->Show();

	system("pause");
	return 0;
}

运行结果：

 

JAVA代码：

package cn.jadeshu.Module;

/**
 * @ClassName: ProductA 
 * @version V1.0
 * @author: jadeshu
 * @Description:抽象工厂方法
 * 1.抽象工厂能生产一系统产品
 */

// 产品A接口
interface ProductA{
	void Show();
}

// 具体产品A1
class ProductA1 implements ProductA{

	@Override
	public void Show() {
		System.out.println("I'm ProductA1");
	}
	
}

// 具体产品A2
class ProductA2 implements ProductA{

	@Override
	public void Show() {
		System.out.println("I'm ProductA2");
	}
	
}

//产品B接口
interface ProductB{
	void Show();
}

// 具体产品B1
class ProductB1 implements ProductB{

	@Override
	public void Show() {
		System.out.println("I'm ProductB1");
	}
	
}

// 具体产品B2
class ProductB2 implements ProductB{

	@Override
	public void Show() {
		System.out.println("I'm ProductB2");
	}
	
}

// 抽象工厂接口(具备能生产产品A和产品B两种产品的能力)
interface AbstractFactory{
	ProductA createProductA();
	ProductB createProductB();
}

// 工厂1(能生产产品A1和产品B1的具体产品)
class Factory1 implements AbstractFactory{

	@Override
	public ProductA createProductA() {
		return new ProductA1();
	}

	@Override
	public ProductB createProductB() {
		return new ProductB1();
	}
	
}

// 工厂2(能生产产品A2和产品B2的具体产品)
class Factory2 implements AbstractFactory{

	@Override
	public ProductA createProductA() {
		return new ProductA2();	
	}

	@Override
	public ProductB createProductB() {
		return new ProductB2();
	}
	
}
public class AbstractFactoryTest {

	public static void main(String[] args) {
		AbstractFactory factory1 = new Factory1();
		ProductA pA1 = factory1.createProductA();
		ProductB pB1 = factory1.createProductB();
		
		pA1.Show();
		pB1.Show();
		
		AbstractFactory factory2 = new Factory2();
		ProductA pA2 = factory2.createProductA();
		ProductB pB2 = factory2.createProductB();
		
		pA2.Show();
		pB2.Show();
	}

}

运行结果：