创建型模式：工厂模式（简单工厂模式，抽象工厂模式，工厂模式）
来源：互联网 发布：手机淘宝开店不了 编辑：程序博客网 时间：2024/05/02 01:56
简单工厂模式
工厂模式中最简单的一种，用比较简单的方式隐藏创建对象的细节。客户端唯一需要知道的是具体子类的类型，工厂类就会返回需要的产品类，但客户端看到的只是产品的抽象对象，无需关心到底是返回了哪个子类。基本是达到了依赖倒转原则的要求。
优点
1.隐藏了对象创建的细节，将产品的实例化推迟到子类。
2.客户端只需要知道用哪个工厂，提供的类型也可以用比较便于识别的字符串。
3.方便添加新的产品子类。
4.遵循了依赖倒转原则。
缺点1.要求产品子类的类型差不多，使用的方法名都相同。
2.每添加一个产品子类，都必须在工厂类中添加一个判断分支，这违背了开放-封闭原则。
工厂模式
工厂模式基本与简单工厂模式差不多，简单工厂模式违背了开放-封闭原则，工厂模式解决了这个问题。
每当添加产品子类的时候，添加一个工厂子类，这遵循了开放-封闭原则。但如果产品数量足够多，要维护的量就会增加，好在工厂子类只用来生成产品类，只要产品子类的名称不发生变化，那么基本工厂子类就不需要修改，每次只需要修改产品子类就可以了。
抽象工厂模式
工厂模式和简单工厂模式要求产品子类必须要是同一类型的，拥有共同的方法，限制了产品子类的扩展。抽象工厂模式将同一类产品子类归为一类，将他们视作一组，然后好几组产品构成一族。
使用时客户端必须知道是哪一个工厂哪一组的产品抽象类。每一个工厂子类负责产生一族产品，工厂子类的一种方法产生一种类型的产品。
优点
1.封装了产品的创建，使得不需要知道具体是哪种产品，只需要知道是哪个工厂。
2.支持不同类型的产品，使得模式灵活性更强。
3.非常方便的使用一族中间的不同类型的产品。
缺点1.结构太过臃肿，如果产品类型比较多，或者产品族类比较多，就会非常难于管理。
2.每次如果添加一组产品，那么所有的工厂类都必须添加一个方法，违背了开放-封闭原则。
简单工厂模式C++实现
AbstractProduct.h
#ifndef _ABSTRACTPRODUCT_H_
#define _ABSTRACTPRODUCT_H_
#include <stdio.h>
class AbstractProduct {
public:
AbstractProduct();
virtual ~AbstractProduct();
virtual void operation() = 0;
};
class ProductA:public AbstractProduct {
public:
ProductA();
virtual ~ProductA();
void operation();
};
class ProductB:public AbstractProduct {
public:
ProductB();
~ProductB();
void operation();
};
#endif
AbstractProduct.cpp
AbstractProduct::AbstractProduct(){}
AbstractProduct::~AbstractProduct(){}
ProductA::ProductA(){}
ProductA::~ProductA(){}
void ProductA::operation() {
fprintf(stderr,"productA operation!\n");
}
ProductB::ProductB(){}
ProductB::~ProductB(){}
void ProductB::operation() {
fprintf(stderr,"productB operation!\n");
}
SimpleFactory.h
#ifndef _SIMPLEFACTORY_H_
#define _SIMPLEFACTROY_H_
#include <stdio.h>
#include "AbstractProduct.h"
class AbstractFactory {
public:
AbstractFactory();
virtual ~AbstractFactory();
virtual AbstractProduct* createProduct(int type) = 0;
};
class SimpleFactory:public AbstractFactory {
public:
SimpleFactory();
~SimpleFactory();
AbstractProduct* createProduct(int type);
};
#endif
SimpleFactory.cpp
#include "SimpleFactory.h"
AbstractFactory::AbstractFactory(){}
AbstractFactory::~AbstractFactory(){}
SimpleFactory::SimpleFactory(){}
SimpleFactory::~SimpleFactory(){}
AbstractProduct* SimpleFactory::createProduct(int type) {
AbstractProduct* temp = NULL;
switch(type)
{
case 1:
temp = new ProductA();
break;
case 2:
temp = new ProductB();
break;
default:
break;
}
return temp;
}
client.cpp
#include "SimpleFactory.h"
int main(){
AbstractFactory* factory = new SimpleFactory();
AbstractProduct* product = factory->createProduct(1);
product->operation();
delete product;
product = NULL;
product = factory->createProduct(2);
product->operation();
delete product;
product = NULL;
return 0;
}
工厂模式C++实现
AbstractProduct.h
#ifndef _ABSTRACTPRODUCT_H_
#define _ABSTRACTPRODUCT_H_
#include <stdio.h>
class AbstractProduct {
public:
AbstractProduct();
virtual ~AbstractProduct();
virtual void operation() = 0;
};
class ProductA:public AbstractProduct {
public:
ProductA();
virtual ~ProductA();
void operation();
};
class ProductB:public AbstractProduct {
public:
ProductB();
~ProductB();
void operation();
};
#endif
AbstractProduct.cpp
#include "AbstractProduct.h"
AbstractProduct::AbstractProduct(){}
AbstractProduct::~AbstractProduct(){}
ProductA::ProductA(){}
ProductA::~ProductA(){}
void ProductA::operation(){
fprintf(stderr,"productA operation!\n");
}
ProductB::ProductB(){}
ProductB::~ProductB(){}
void ProductB::operation(){
fprintf(stderr,"productB operation!\n");
}
AbstractFactory.h
#ifndef _SIMPLEFACTORY_H_
#define _SIMPLEFACTROY_H_
#include <stdio.h>
#include "AbstractProduct.h"
class AbstractFactory {
public:
AbstractFactory();
virtual ~AbstractFactory();
virtual AbstractProduct* createProduct() = 0;
};
class FactoryA:public AbstractFactory {
public:
FactoryA();
~FactoryA();
AbstractProduct* createProduct();
};
class FactoryB:public AbstractFactory {
public:
FactoryB();
~FactoryB();
AbstractProduct* createProduct();
};
#endif
AbstractFactory.cpp
#include "AbstractFactory.h"
AbstractFactory::AbstractFactory(){}
AbstractFactory::~AbstractFactory(){}
FactoryA::FactoryA(){}
FactoryA::~FactoryA(){}
AbstractProduct* FactoryA::createProduct(){
AbstractProduct* temp = NULL;
temp = new ProductA();
return temp;
}
FactoryB::FactoryB(){}
FactoryB::~FactoryB(){}
AbstractProduct* FactoryB::createProduct(){
AbstractProduct* temp = NULL;
temp = new ProductB();
return temp;
}
client.cpp
#include "AbstractFactory.h"
int main(){
AbstractFactory* factory = new FactoryA();
AbstractProduct* product = factory->createProduct();
product->operation();
delete product;
product = NULL;
delete factory;
factory = NULL;
factory = new FactoryB();
product = factory->createProduct();
product->operation();
delete product;
product = NULL;
delete factory;
factory = NULL;
return 0;
}
抽象工厂模式C++实现
AbstractProductA.h
#ifndef _ABSTRACTPRODUCTA_H_
#define _ABSTRACTPRODUCTA_H_
#include <stdio.h>
class AbstractProductA {
public:
AbstractProductA();
virtual ~AbstractProductA();
virtual void operationA() = 0;
};
class ProductA_1:public AbstractProductA {
public:
ProductA_1();
virtual ~ProductA_1();
void operationA();
};
class ProductA_2:public AbstractProductA {
public:
ProductA_2();
~ProductA_2();
void operationA();
};
#endif
AbstractProductA.cpp
#include "AbstractProductA.h"
AbstractProductA::AbstractProductA(){}
AbstractProductA::~AbstractProductA(){}
ProductA_1::ProductA_1(){}
ProductA_1::~ProductA_1(){}
void ProductA_1::operationA(){
fprintf(stderr,"productA_1 operation!\n");
}
ProductA_2::ProductA_2(){}
ProductA_2::~ProductA_2(){}
void ProductA_2::operationA(){
fprintf(stderr,"productA_2 operation!\n");
}
AbstractProductB.h
#ifndef _ABSTRACTPRODUCTB_H_
#define _ABSTRACTPRODUCTB_H_
#include <stdio.h>
class AbstractProductB {
public:
AbstractProductB();
virtual ~AbstractProductB();
virtual void operationB() = 0;
};
class ProductB_1:public AbstractProductB {
public:
ProductB_1();
virtual ~ProductB_1();
void operationB();
};
class ProductB_2:public AbstractProductB {
public:
ProductB_2();
~ProductB_2();
void operationB();
};
#endif
AbstractProductB.cpp
#include "AbstractProductB.h"
AbstractProductB::AbstractProductB(){}
AbstractProductB::~AbstractProductB(){}
ProductB_1::ProductB_1(){}
ProductB_1::~ProductB_1(){}
void ProductB_1::operationB(){
fprintf(stderr,"productB_1 operation!\n");
}
ProductB_2::ProductB_2(){}
ProductB_2::~ProductB_2(){}
void ProductB_2::operationB(){
fprintf(stderr,"productB_2 operation!\n");
}
AbstractFactory.h
#ifndef _SIMPLEFACTORY_H_
#define _SIMPLEFACTROY_H_
#include <stdio.h>
#include "AbstractProductA.h"
#include "AbstractProductB.h"
class AbstractFactory {
public:
AbstractFactory();
virtual ~AbstractFactory();
virtual AbstractProductA* createProductA() = 0;
virtual AbstractProductB* createProductB() = 0;
};
class Factory1:public AbstractFactory {
public:
Factory1();
~Factory1();
AbstractProductA* createProductA();
AbstractProductB* createProductB();
};
class Factory2:public AbstractFactory {
public:
Factory2();
~Factory2();
AbstractProductA* createProductA();
AbstractProductB* createProductB();
};
#endif
AbstractFactory.cpp
#include "AbstractFactory.h"
AbstractFactory::AbstractFactory(){}
AbstractFactory::~AbstractFactory(){}
Factory1::Factory1(){}
Factory1::~Factory1(){}
AbstractProductA* Factory1::createProductA(){
AbstractProductA* temp = NULL;
temp = new ProductA_1();
return temp;
}
AbstractProductB* Factory1::createProductB(){
AbstractProductB* temp = NULL;
temp = new ProductB_1();
return temp;
}
Factory2::Factory2(){}
Factory2::~Factory2(){}
AbstractProductA* Factory2::createProductA(){
AbstractProductA* temp = NULL;
temp = new ProductA_2();
return temp;
}
AbstractProductB* Factory2::createProductB(){
AbstractProductB* temp = NULL;
temp = new ProductB_2();
return temp;
}
client.cpp
#include "AbstractFactory.h"
int main() {
AbstractFactory* factory = new Factory1();
AbstractProductA* productA = factory->createProductA();
AbstractProductB* productB = factory->createProductB();
productA->operationA();
productB->operationB();
delete factory;
factory = NULL;
delete productA;
productA = NULL;
delete productB;
productB = NULL;
factory = new Factory2();
productA = factory->createProductA();
productB = factory->createProductB();
productA->operationA();
productB->operationB();
delete factory;
factory = NULL;
delete productA;
productA = NULL;
delete productB;
productB = NULL;
return 0;
}
- 创建型模式：工厂模式（简单工厂模式，抽象工厂模式，工厂模式）
- 简单工厂、工厂模式、抽象工厂模式
- 简单工厂、工厂模式、抽象工厂模式
- 简单工厂&工厂模式&抽象工厂模式
- 工厂模式 抽象工厂模式 (创建模式)
- 简单工厂/工厂/抽象工厂模式（创建类）
- 设计模式(简单工厂模式，工厂模式，抽象工厂模式)
- 工厂模式 -- 抽象工厂
- 工厂模式-抽象工厂
- 工厂模式-抽象工厂
- 创建型模式01：简单工厂模式、工厂方法模式、抽象工厂模式
- "围观"设计模式(8)--创建型之简单工厂模式、工厂方法模式、抽象工厂模式
- "围观"设计模式(8)--创建型之简单工厂模式、工厂方法模式、抽象工厂模式
- 简单工厂，工厂模式，抽象工厂
- 简单工厂，工厂模式，抽象工厂
- 简单工厂、工厂方法、抽象工厂模式
- 简单工厂、工厂模式和抽象工厂
- 简单工厂、工厂方法、抽象工厂模式
- 2015.9.13 PHP学习入门篇
- VMware虚拟机没有卸载干净无法重装的问题解决之道
- MJPhotoBrowser的简单使用
- Centos 安装Mysql5.7
- MySQL导入中文乱码解决之道
- 创建型模式：工厂模式（简单工厂模式，抽象工厂模式，工厂模式）
- c++中的引用和指针的区别和相关例子
- hihocoder 1015 KMP
- 《Java面向对象程序设计》
- 仿百度文库方案[openoffice.org 3+swftools+flexpaper] 使用JODConverter将office文档转换为pdf
- Android事件处理机制轻量级源码分析
- 使用Backtrace函数打印调用栈 - Debug居家必备
- 软件工程之软件工程概论
- 文章标题
