(Java实现)设计模式之三种工厂模式(简单工厂、工厂方法、抽象方法)

主要思想来源：清华大学出版社设计模式讲解ppt课件

简单工厂

概述

简单工厂模式(Simple Factory Pattern)：又称为静态工厂方法(Static Factory Method)模式，它属于类创建型模式 在简单工厂模式中，可以根据参数的不同返回不同类的实例 简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

模式结构

简单工厂模式包含如下角色：

●Factory：工厂角色

●Product：抽象产品角色

●ConcreteProduct：具体产品角色

模式分析

●将对象的创建和对象本身业务处理分离可以降低系统的耦合度，使得两者修改起来都相对容易

●在调用工厂类的工厂方法时，由于工厂方法是静态方法，使用起来很方便，可通过工厂类类名直接调用，只需要传入一个简单的参数即可，无须知道对象的创建细节

●可以将参数保存在XML等格式的配置文件中，修改时无须修改任何Java源代码

●问题：工厂类的职责相对过重，增加新的产品需要修改工厂类的判断逻辑，违背开闭原则

模式实例

问题描述

使用简单工厂模式模拟女娲（Nvwa）造人（Person），如果传入参数M，则返回一个Man对象，如果传入参数W，则返回一个Woman对象，请实现该场景。现需要增加一个新的Robot类，如果传入参数R，则返回一个Robot对象，对代码进行修改并注意女娲的变化。

问题分析

在本实例中，NvWa为工厂类，其中定义了工厂方法CreteCreature()根据传入的参数返回相应的实例对象，Creature接口为抽象产品类，其中定义了产品方法create()模拟对应的女娲造人过程，Man、Woman和Robot为具体产品类。 

UML参考类图

参考代码

// 使用简单工厂模式模拟女娲（Nvwa）造人（Person），如果传入参数M，则返回一个Man对象，如果传入参数W，则返回一个Woman对象，请实现该场景。现需要增加一个新的Robot类，如果传入参数R，则返回一个Robot对象，对代码进行修改并注意女娲的变化。

class SimpleFactory{
    public static void main(String [] args)
    {
       Creature creature = NvWa.CreateCreature('R');
        creature.create();
    }
}

class NvWa{
    public static Creature CreateCreature(char arg)
    {
        Creature creature = null;
        switch(arg)
        {
            case 'M':
                 creature  = new Man();
                 break;
            case 'W':
                 creature = new Woman();
                 break;
            case 'R':
                 creature = new Robot();
                 break;
            default:
                 break;
        }
        return creature;
    }
}

interface Creature{
    void create();
}

class Man implements Creature{
    public void create()
    {
        System.out.println("女娲造了一个男人!");
    }
}

class Woman implements Creature{
    public void create()
    {
        System.out.println("女娲造了一个女人!");
    }
}

class Robot implements Creature{
    public void create()
    {
        System.out.println("女娲造了一个机器人!");
    }
}

模式效果与应用

简单工厂模式优点：

●实现了对象创建和使用的分离

●客户端无须知道所创建的具体产品类的类名，只需要知道具体产品类所对应的参数即可，通过引入配置文件，可以在不修改任    何客户端代码的情况下更换和增加新的具体产品类，在一定程度上提高了系统的灵活性

（本实例没有用xml配置文件传参 !-_-）

简单工厂模式缺点：

●工厂类集中了所有产品的创建逻辑，职责过重，一旦不能正常工作，整个系统都要受到影响

● 增加系统中类的个数（引入了新的工厂类），增加了系统的复杂度和理解难度

●系统扩展困难，一旦添加新产品不得不修改工厂逻辑

● 由于使用了静态工厂方法，造成工厂角色无法形成基于继承的等级结构，工厂类不能得到很好地扩展

在以下情况下可以使用简单工厂模式：

●工厂类负责创建的对象比较少：由于创建的对象较少，不会造成工厂方法中的业务逻辑太过复杂

● 客户端只知道传入工厂类的参数，对于如何创建对象不关心：客户端既不需要关心创建细节，甚至连类名都不需要记住，只需知道类型所对应的参数

工厂方法

模式动机

原有的简单工厂模式必须修改工厂类，违反了开闭原则。

概述

工厂方法模式(Factory Method Pattern)简称工厂模式，也叫虚拟构造器(Virtual Constructor)模式或者多态工厂(Polymorphic Factory)模式，它属于类创建型模式。 在工厂方法模式中，工厂父类负责定义创建产品对象的公共接口，而工厂子类则负责生成具体的产品对象，这样做的目的是将产品类的实例化操作延迟到工厂子类中完成，即通过工厂子类来确定究竟应该实例化哪一个具体产品类。

模式结构

简单工厂模式包含如下角色：

●Product：抽象产品

●ConcreteProduct：具体产品

●Factory：抽象工厂

●ConcreteFactory：具体工厂

模式分析

●工厂方法模式是简单工厂模式的进一步抽象和推广

●工厂方法模式保持了简单工厂模式的优点，并克服了它的缺点

●核心的工厂类不再负责所有产品的创建，而是将具体创建工作交给其子类去完成

●可以允许系统在不修改工厂角色的情况下引进新产品

●增加具体产品-->增加具体工厂，符合“开闭原则”

模式实例

问题描述

海尔工厂(Haier)生产海尔空调(HaierAirConditioner)，美的工厂(Midea)生产美的空调(MideaAirConditioner) 。使用工厂方法模式描述该场景。

问题分析

在本实例中，AirConditioner为抽象产品类，其中定义了产品方法cool()模拟空调产品制冷的过程，HaierAirCondition、MideaAirConditioner为具体产品类，AirConditionerFactory为抽象工厂类，其中定义了工厂方法produceAirConditioner()生产对应的产品。

UML参考类图

  参考代码

public class FactoryMethod{
    public static void main(String[] args)
    {
        AirConditionerFactory airconditionerfactory = new HaierAirConditionerFactory();
        AirConditioner airconditioner = airconditionerfactory.produceAirConditioner();
        airconditioner.cool();
    }
}

//抽象产品
interface AirConditioner{
    void cool();
}

//抽象工厂
interface AirConditionerFactory{
    AirConditioner produceAirConditioner();
}

//具体产品海尔空调
class HaierAirConditioner implements AirConditioner{
    public void cool()
    {
        System.out.println("海尔空调制冷中......");
    }
}

//具体产品美的空调
class MideaAirConditioner implements AirConditioner{
    public void cool()
    {
        System.out.println("美的空调制冷中......");
    }
}

//具体工厂生产海尔空调
class HaierAirConditionerFactory implements AirConditionerFactory{
    public AirConditioner produceAirConditioner()
    {
        System.out.println("海尔空调工厂生产海尔空调");
        return new HaierAirConditioner();
    }
}

//具体工厂生产美的空调
class MideaAirConditionerFactory implements AirConditionerFactory{
    public AirConditioner produceAirConditioner()
    {
        System.out.println("美的空调工厂生产美的空调");
        return new MideaAirConditioner();
    }
}

模式效果与应用

工厂方法模式优点：

●工厂方法用来创建客户所需要的产品，同时还向客户隐藏了哪种具体产品类将被实例化这一细节

●能够让工厂自主确定创建何种产品对象，而如何创建这个对象的细节则完全封装在具体工厂内部

●在系统中加入新产品时，完全符合开闭原则

工厂方法模式缺点：

●系统中类的个数将成对增加，在一定程度上增加了系统的复杂度，会给系统带来一些额外的开销

●增加了系统的抽象性和理解难度

在以下情况下可以使用工厂方法模式：

●客户端不知道它所需要的对象的类（客户端不需要知道具体产品类的类名，只需要知道所对应的工厂即可，具体产品对象由具体工厂类创建）

● 抽象工厂类通过其子类来指定创建哪个对象

抽象工厂

模式动机

● 产品等级结构：产品等级结构即产品的继承结构，例如一个抽象类是电视机，其子类有海尔电视机、海信电视机、TCL电视机，则抽象电视机与具体品牌的电视机之间构成了一个产品等级结构，抽象电视机是父类，而具体品牌的电视机是其子类。

● 产品族：在抽象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品，例如海尔电器工厂生产的海尔电视机、海尔电冰箱，海尔电视机位于电视机产品等级结构中，海尔电冰箱位于电冰箱产品等级结构中。

概述

抽象工厂模式(Abstract Factory Pattern)：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，属于对象创建型模式。

模式结构

抽象工厂模式包含如下角色：

●AbstractFactory：抽象工厂

●ConcreteFactory：具体工厂

●AbstractProduct：抽象产品

●ConcreteProduct：具体产品

模式分析

模式实例

问题描述

电脑配件生产工厂生产内存、CPU等硬件设备，这些内存、CPU的品牌、型号并不一定相同，根据下面的“产品等级结构-产品族”示意图，使用抽象工厂模式实现电脑配件生产过程。

问题分析

在本实例中，AFactory为抽象工厂类，PcFactory和MacFacory为具体工厂类，分别对应每一个品牌的产品族；Ram,Cpu为抽象产品类，PcRam、MacRam，PcCpu、MacCpu为具体产品类，分别对应不同类别的产品，即产品等级。

UML参考类图

参考代码

public class AbstractFactory{
    public static void main(String[] args)
    {
        AFactory abstractfactory;
        Ram ram;
        Cpu cpu;
        abstractfactory = new MacFactory();
        ram = abstractfactory.produceRam();
        ram.randomaccess();
        cpu = abstractfactory.produceCpu();
        cpu.centralprocess();
    }
}

//抽象工厂AFactory
interface AFactory
{
    public Ram produceRam();
    public Cpu produceCpu();
}

//具体工厂PcFactory
class PcFactory implements AFactory
{
    public Ram produceRam()
    {
        return new PcRam();
    }
    public Cpu produceCpu()
    {
        return new PcCpu();
    }
}

//具体工厂MacFactory
class MacFactory implements AFactory
{
    public Ram produceRam()
    {
        return new MacRam();
    }
    public Cpu produceCpu()
    {
        return new MacCpu();
    }
}

//抽象产品Ram
interface Ram
{
    public void randomaccess();
}

//抽象产品Cpu
interface Cpu
{
    public void centralprocess();
}

//具体产品PcRam
class PcRam implements Ram
{
    public void randomaccess()
    {
        System.out.println("Pc的RAM随机存储器......");
    }
}

//具体产品PcCpu
class MacRam implements Ram
{
    public void randomaccess()
    {
        System.out.println("Mac的RAM随机存储器......");
    }
}

//具体产品PcCpu
class PcCpu implements Cpu
{
    public void centralprocess()
    {
        System.out.println("Pc的Cpu中央处理器......");
    }
}

//具体产品MacCpu
class MacCpu implements Cpu
{
    public void centralprocess()
    {
        System.out.println("Mac的Cpu中央处理器......");
    }
}

模式效果与应用

抽象工厂方法模式优点：

●隔离了具体类的生成，使得客户端并不需要知道什么被创建

●当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象

●增加新的产品族很方便，无须修改已有系统，符合开闭原则

抽象工厂方法模式缺点：

●增加新的产品等级结构麻烦，需要对原有系统进行较大的修改，甚至需要修改抽象层代码，这显然会带来较大的不便，违背了开闭原则

在以下情况下可以使用抽象工厂方法模式：

●一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节

● 系统中有多于一个的产品族，但每次只使用其中某一产品族

● 属于同一个产品族的产品将在一起使用，这一约束必须在系统的设计中体现出来

● 产品等级结构稳定，在设计完成之后不会向系统中增加新的产品等级结构或者删除已有的产品等级结构