设计模式——抽象工厂（Abstract Factory）

51 阅读 0 评论 34 点赞

我是靠谱客的博主细心火龙果，最近开发中收集的这篇文章主要介绍设计模式——抽象工厂（Abstract Factory），觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

前言

本文只是记录本人学习设计模式时记录的一些学习笔记，可能不全，但是可以做到一些提醒记忆的作用，如有侵权，联系删改，文章后会贴出学习时参考的链接。此前言适用于本人所写设计模式系列。

抽象工厂

为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。

可理解为比工厂方法又多了一维

简单工厂, 是针对一种"类型"的抽象;
工厂方法, 是针对一种"类型", 以及一种"创建方法"的抽象;
抽象工厂, 是针对一组"类型"与"创建方法"的抽象, 组内每一套类型与创建方法一一对应.

结构

抽象工厂（Creator）角色

抽象工厂模式的核心，包含对多个产品结构的声明，任何工厂类都必须实现这个接口。

具体工厂（ Concrete Creator）角色

具体工厂类是抽象工厂的一个实现，负责实例化某个产品族中的产品对象。

抽象（Product）角色

抽象模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。

具体产品（Concrete Product）角色

抽象模式所创建的具体实例对象

示例

一个工厂类可以同时生成一个产品族

#include <iostream>
using namespace std;
class AbstractAPPle{
public:
virtual void ShowName() = 0;
virtual ~AbstractAPPle(){};
};
class ChinaApple : public AbstractAPPle{
virtual void ShowName()override{
cout << "I am China Apple!" << endl;
}
};
class USAApple : public AbstractAPPle{
virtual void ShowName()override{
cout << "I am USA Apple!" << endl;
}
};
class JapanApple : public AbstractAPPle{
virtual void ShowName()override{
cout << "I am Japan Apple!" << endl;
}
};
class AbstractBanana{
public:
virtual void ShowName() = 0;
virtual ~AbstractBanana(){};
};
class ChinaBanana : public AbstractBanana{
virtual void ShowName()override{
cout << "I am China Banana!" << endl;
}
};
class USABanana : public AbstractBanana{
virtual void ShowName()override{
cout << "I am USA Banana!" << endl;
}
};
class JapanBanana : public AbstractBanana{
virtual void ShowName()override{
cout << "I am Japan Banana!" << endl;
}
};
class AbstractPear{
public:
virtual void ShowName() = 0;
virtual ~AbstractPear(){};
};
class ChinaPear : public AbstractPear{
virtual void ShowName()override{
cout << "I am China Pear!" << endl;
}
};
class USAPear : public AbstractPear{
virtual void ShowName()override{
cout << "I am USA Pear!" << endl;
}
};
class JapanPear : public AbstractPear{
virtual void ShowName()override{
cout << "I am Japan Pear!" << endl;
}
};
class AbstractFactory{
public:
virtual AbstractAPPle* CreateAPPle() = 0;
virtual AbstractBanana* CreateBanana() = 0;
virtual AbstractPear* CreatePear() = 0;
virtual ~AbstractFactory(){};
};
class ChinaFactory : public AbstractFactory{
public:
virtual AbstractAPPle* CreateAPPle(){
return new ChinaApple;
}
virtual AbstractBanana* CreateBanana(){
return new ChinaBanana;
}virtual AbstractPear* CreatePear(){
return new ChinaPear;
}
};
class USAFactory : public AbstractFactory{
public:
virtual AbstractAPPle* CreateAPPle(){
return new USAApple;
}
virtual AbstractBanana* CreateBanana(){
return new USABanana;
}virtual AbstractPear* CreatePear(){
return new USAPear;
}
};
class JapanFactory : public AbstractFactory{
public:
virtual AbstractAPPle* CreateAPPle(){
return new JapanApple;
}
virtual AbstractBanana* CreateBanana(){
return new JapanBanana;
}virtual AbstractPear* CreatePear(){
return new JapanPear;
}
};
int main()
{
AbstractFactory* factory = NULL;
AbstractAPPle* apple = NULL;
AbstractBanana* banana = NULL;
AbstractPear* pear = NULL;
factory = new ChinaFactory;
apple = factory->CreateAPPle();
banana = factory->CreateBanana();
pear = factory->CreatePear();
apple->ShowName();
banana->ShowName();
pear->ShowName();
delete pear;
delete banana;
delete apple;
delete factory;
factory = new USAFactory;
apple = factory->CreateAPPle();
banana = factory->CreateBanana();
pear = factory->CreatePear();
apple->ShowName();
banana->ShowName();
pear->ShowName();
delete pear;
delete banana;
delete apple;
delete factory;
return 0;
}