设计模式——7.抽象工厂

抽象工厂（Abstract Factory）

Abstract Factory模式简介：

提供一个创建一系列相关或者相互依赖对象的接口，而无需指定它们具体的类。

Abstract Factory模式结构：

C++代码

AbstractProductA抽象类以及1系列和2系列的具体实现类：

//file: AbstractProductA.h
#pragma once
class AbstractProductA
{
public:
	AbstractProductA();
	virtual ~AbstractProductA();
	
	virtual void stepA() = 0;
};

class ProductA1 : public AbstractProductA
{
public:
	ProductA1();
	virtual ~ProductA1();

	void stepA();
};

class ProductA2 : public AbstractProductA
{
public:
	ProductA2();
	virtual ~ProductA2();

	void stepA();
};

//file: AbstractProductA.cpp
#include "pch.h"
#include "AbstractProductA.h"
#include <iostream>
using namespace std;

//AbstractProductA
AbstractProductA::AbstractProductA() {}

AbstractProductA::~AbstractProductA() {}


//ProductA1
ProductA1::ProductA1() {}

ProductA1::~ProductA1() {}

void ProductA1::stepA()
{
	cout << "Product A1's step !" << endl;
}

//ProductA2
ProductA2::ProductA2() {}

ProductA2::~ProductA2() {}

void ProductA2::stepA()
{
	cout << "Product A2's step !" << endl;
}

AbstractProductB抽象类以及1系列和2系列的具体实现类：

//file: AbstractProductB.h
#pragma once
class AbstractProductB
{
public:
	AbstractProductB();
	virtual ~AbstractProductB();

	virtual void stepB() = 0;
};

class ProductB1 : public AbstractProductB
{
public:
	ProductB1();
	virtual ~ProductB1();

	void stepB();
};

class ProductB2 : public AbstractProductB
{
public:
	ProductB2();
	virtual ~ProductB2();

	void stepB();
};

//file: AbstractProductB.cpp
#include "pch.h"
#include "AbstractProductB.h"
#include <iostream>
using namespace std;

//AbstractProductB
AbstractProductB::AbstractProductB() {}

AbstractProductB::~AbstractProductB() {}

//ProductB1
ProductB1::ProductB1() {}

ProductB1::~ProductB1() {}

void ProductB1::stepB()
{
	cout << "Product B1's step ! " << endl;
}

//ProductB2
ProductB2::ProductB2() {}

ProductB2::~ProductB2() {}

void ProductB2::stepB()
{
	cout << "Product B2's step ! " << endl;
}

AbstractFractory以及1系列和2系列的ConcreteFractory：

//file: AbstractFactory.h
#pragma once
#include "AbstractProductA.h"
#include "AbstractProductB.h"

class AbstractFactory
{
public:
	AbstractFactory();
	virtual ~AbstractFactory();

	virtual AbstractProductA* createProductA() = 0;
	virtual AbstractProductB* createProductB() = 0;
};

class ConcreteFactory1 : public AbstractFactory
{
public:
	ConcreteFactory1();
	virtual ~ConcreteFactory1();

	virtual AbstractProductA* createProductA();
	virtual AbstractProductB* createProductB();
};

class ConcreteFactory2 : public AbstractFactory
{
public:
	ConcreteFactory2();
	virtual ~ConcreteFactory2();

	virtual AbstractProductA* createProductA();
	virtual AbstractProductB* createProductB();
};

//file: AbstractFractory.cpp
#include "pch.h"
#include "AbstractFactory.h"

//AbstractFactory
AbstractFactory::AbstractFactory() {}

AbstractFactory::~AbstractFactory() {}

//ConcreteFactory1
ConcreteFactory1::ConcreteFactory1() {}

ConcreteFactory1::~ConcreteFactory1() {}

AbstractProductA* ConcreteFactory1::createProductA()
{
	return new ProductA1();
}

AbstractProductB* ConcreteFactory1::createProductB()
{
	return new ProductB1();
}

//ConcreteFactory2
ConcreteFactory2::ConcreteFactory2() {}

ConcreteFactory2::~ConcreteFactory2() {}

AbstractProductA* ConcreteFactory2::createProductA()
{
	return new ProductA2();
}

客户端调用代码：

// AbstractFactoryPattern.cpp : This file contains the 'main' function. Program execution begins and ends there.
#include "pch.h"
#include "AbstractFactory.h"
#include <iostream>
using namespace std;

int main()
{
	AbstractFactory* frac = new ConcreteFactory1();
	//AbstractFactory* frac = new ConcreteFactory2();
	AbstractProductA* pa = frac->createProductA();
	AbstractProductB* pb = frac->createProductB();

	pa->stepA();
	pb->stepB();

	delete frac;
	delete pa;
	delete pb;
	
	char c;
	cin >> c;
	return 0;
}

C#代码

AbstractProductA抽象类以及1系列和2系列的具体实现类：

public abstract class AbstractProductA
{
	public abstract void StepA();
}

public class ProductA1 : AbstractProductA
{
	public override void StepA()
	{
		Console.WriteLine("Product A1's Step !");
	}
}

public class ProductA2 : AbstractProductA
{
	public override void StepA()
	{
		Console.WriteLine("Product A2's Step !");
	}
}

AbstractProductB抽象类以及1系列和2系列的具体实现类：

public abstract class AbstractProductB
{
	public abstract void StepB();
}

public class ProductB1 : AbstractProductB
{
	public override void StepB()
	{
		Console.WriteLine("Product B1's Step ！");
	}
}

public class ProductB2 : AbstractProductB
{
	public override void StepB()
	{
		Console.WriteLine("Product B2's Step !");
	}
}

AbstractFractory以及1系列和2系列的ConcreteFractory：

public abstract class AbstractFactory
{
	public abstract AbstractProductA CreatProductA();
	public abstract AbstractProductB CreatProductB();
}

public class ConcreteFactory1 : AbstractFactory
{
	public override AbstractProductA CreatProductA()
	{
		return new ProductA1();
	}

	public override AbstractProductB CreatProductB()
	{
		return new ProductB1();
	}
}

public class ConcreteFactory2 : AbstractFactory
{
	public override AbstractProductA CreatProductA()
	{
		return new ProductA2();
	}

	public override AbstractProductB CreatProductB()
	{
		return new ProductB2();
	}
}

客户端代码：

AbstractFactory frac = new ConcreteFactory1();
//AbstractFactory frac = new ConcreteFactory2();

AbstractProductA pa = frac.CreatProductA();
AbstractProductB pb = frac.CreatProductB();
pa.StepA();
pb.StepB();

REF

书籍：

设计模式与游戏开发、大话设计模式

GitHub：

https://github.com/me115/design_patterns