[设计模式]工厂方法模式
目录
简介
结构
图-工厂方法模式结构图
Product : 定义产品对象的接口。
public abstract void Use();
}
ConcreteProduct : 实现 Product 接口。
public ConcreteProduct() {
System.out.println("创建 ConcreteProduct 产品");
}
@Override
public void Use() {
System.out.println("使用 ConcreteProduct 产品");
}
}
Creator : 声明工厂方法，它会返回一个产品类型的对象。 Creator 也可以实现一个默认的工厂方法 FactoryMethod() ，以返回一个默认的具体产品类型。
public Product FactoryMethod();
}
ConcreteCreator : 覆写 Creator 中的工厂方法 FactoryMethod() 。
@Override
public Product FactoryMethod() {
return new ConcreteProduct();
}
}
测试代码
public static void main(String[] args) {
Creator factory = new ConcreteCreator();
Product product = factory.FactoryMethod();
product.Use();
}
}
运行结果
使用 ConcreteProduct 产品
动机
当一个类不知道它所必须创建的对象的类的时候。
当一个类希望由它的子类来指定它所创建的对象的时候。
当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将是代理者的帮助子类的信息局部化的时候。
要点
因为每个工厂类只能创建一种产品的实例。
2、工厂模式遵循开放-封闭原则。
工厂模式中，新增一种产品并不需要修改原有类，仅仅是扩展。
实例
还是以 简单工厂模式 里的例子来进行说明。
两种模式的 Product 和 ConcreteProduct 角色代码没有区别，不再赘述。
差异在于 Factory 角色部分，以及客户端部分，请在代码中体会。
Creator 角色
interface OperationFactory {
public Operation FactoryMethod();
}
ConcreteCreator 角色
和简单工厂模式相比，每一种产品都会有一个具体的工厂类负责生产实例。
class AddFactory implements OperationFactory {
@Override
public Operation FactoryMethod() {
return new Add();
}
}
// ConcreteCreator 角色，具体实现 Creator 中的方法
class SubFactory implements OperationFactory {
@Override
public Operation FactoryMethod() {
return new Sub();
}
}
// ConcreteCreator 角色，具体实现 Creator 中的方法
class MulFactory implements OperationFactory {
@Override
public Operation FactoryMethod() {
return new Mul();
}
}
// ConcreteCreator 角色，具体实现 Creator 中的方法
class DivFactory implements OperationFactory {
@Override
public Operation FactoryMethod() {
return new Div();
}
}
Client 角色
与简单工厂模式中无需关注具体创建不同，工厂模式中需要指定具体工厂，以负责生产具体对应的产品。
public class FactoryMethodPattern {
public static void main(String[] args) {
OperationFactory factory = new SubFactory();
Operation oper = factory.FactoryMethod();
oper.numA = 3;
oper.numB = 2;
double result = oper.getResult();
System.out.println("result = " + result);
}
}
C++版工厂方法模式
以下为一个C++版的工厂方法模式例子。
假设有两个台灯制造工厂，一个专门生产红色的灯，一个专门生产蓝色的灯。
在客户端里，我们实例化蓝灯工厂，来生产一个蓝灯。
#include <string>
#include <iostream>
using namespace std;
//Product
class Light
{
public:
virtual void TurnOn() = 0;
virtual void TurnOff() = 0;
};
class BlueLight : public Light
{
public:
void TurnOn()
{
cout << "Turn on BlueLight." << endl;
}
void TurnOff()
{
cout << "Turn off BlueLight." << endl;
}
};
class RedLight : public Light
{
public:
void TurnOn()
{
cout << "Turn on RedLight." << endl;
}
void TurnOff()
{
cout << "Turn off RedLight." << endl;
}
};
//Factory
class Factory
{
public:
virtual Light* CreateLight() = 0;
};
class BlueLightFactory : public Factory
{
public:
Light* CreateLight()
{
return new BlueLight;
}
};
class RedLightFactory : public Factory
{
public:
Light* CreateLight()
{
return new RedLight;
}
};
int main()
{
Factory *pBlueLightFactory = new BlueLightFactory;
Light *pBlueLight = pBlueLightFactory->CreateLight();
pBlueLight->TurnOn();
pBlueLight->TurnOff();
free(pBlueLight)
free(pBlueLightFactory);
return 0;
}
简单工厂模式相比于工厂方法模式
优点：工厂类中包含必要的逻辑判断，可根据客户端的选择条件动态实例化需要的类。对于客户端来说，去除了对具体产品的依赖。
缺点：违背了开放封闭原则。 每添加一个新的产品，都需要对原有类进行修改。增加维护成本，且不易于维护。
推荐阅读
本文属于 设计模式系列 。
