设计模式之工厂模式（factory pattern）

工厂顾名思义就是建立产品，根据产品是具体产品仍是具体工厂可分为简单工厂模式和工厂方法模式，根据工厂的抽象程度可分为工厂方法模式和抽象工厂模式。该模式用于封装和管理对象的建立，是一种建立型模式。本文从一个具体的例子逐步深刻分析，来体会三种工厂模式的应用场景和利弊。

1. 简单工厂模式

该模式对对象建立管理方式最为简单，由于其仅仅简单的对不一样类对象的建立进行了一层薄薄的封装。该模式经过向工厂传递类型来指定要建立的对象，其UML类图以下：

下面咱们使用手机生产来说解该模式：

Phone类：手机标准规范类(AbstractProduct)

public interface Phone {
    void make();
}

  MiPhone类：制造小米手机（Product1）

public class MiPhone implements Phone {
    public MiPhone() {
        this.make();
    }
    @Override
    public void make() {
        // TODO Auto-generated method stub
        System.out.println("make xiaomi phone!");
    }
}

IPhone类：制造苹果手机（Product2）

public class IPhone implements Phone {
    public IPhone() {
        this.make();
    }
    @Override
    public void make() {
        // TODO Auto-generated method stub
        System.out.println("make iphone!");
    }
}

PhoneFactory类：手机代工厂（Factory）

public class PhoneFactory {
    public Phone makePhone(String phoneType) {
        if(phoneType.equalsIgnoreCase("MiPhone")){
            return new MiPhone();
        }
        else if(phoneType.equalsIgnoreCase("iPhone")) {
            return new IPhone();
        }
        return null;
    }
}

 演示：

public class Demo {
    public static void main(String[] arg) {
        PhoneFactory factory = new PhoneFactory();
        Phone miPhone = factory.makePhone("MiPhone");            // make xiaomi phone!
        IPhone iPhone = (IPhone)factory.makePhone("iPhone");    // make iphone!
    }
}

2. 工厂方法模式(Factory Method)

和简单工厂模式中工厂负责生产全部产品相比，工厂方法模式将生成具体产品的任务分发给具体的产品工厂，其UML类图以下：

也就是定义一个抽象工厂，其定义了产品的生产接口，但不负责具体的产品，将生产任务交给不一样的派生类工厂。这样不用经过指定类型来建立对象了。

接下来继续使用生产手机的例子来说解该模式。

其中和产品相关的Phone类、MiPhone类和IPhone类的定义不变。

AbstractFactory类：生产不一样产品的工厂的抽象类

public interface AbstractFactory {
    Phone makePhone();
}

XiaoMiFactory类：生产小米手机的工厂（ConcreteFactory1）

public class XiaoMiFactory implements AbstractFactory{
    @Override
    public Phone makePhone() {
        return new MiPhone();
    }
}

AppleFactory类：生产苹果手机的工厂（ConcreteFactory2）

public class AppleFactory implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new IPhone();
    }
}

演示：

public class Demo {
    public static void main(String[] arg) {
        AbstractFactory miFactory = new XiaoMiFactory();
        AbstractFactory appleFactory = new AppleFactory();
        miFactory.makePhone();            // make xiaomi phone!
        appleFactory.makePhone();        // make iphone!
    }
}

3. 抽象工厂模式(Abstract Factory)

上面两种模式无论工厂怎么拆分抽象，都只是针对一类产品Phone（AbstractProduct），若是要生成另外一种产品PC，应该怎么表示呢？

最简单的方式是把2中介绍的工厂方法模式彻底复制一份，不过此次生产的是PC。但同时也就意味着咱们要彻底复制和修改Phone生产管理的全部代码，显然这是一个笨办法，并不利于扩展和维护。

抽象工厂模式经过在AbstarctFactory中增长建立产品的接口，并在具体子工厂中实现新加产品的建立，固然前提是子工厂支持生产该产品。不然继承的这个接口能够什么也不干。

其UML类图以下：

从上面类图结构中能够清楚的看到如何在工厂方法模式中经过增长新产品接口来实现产品的增长的。

接下来咱们继续经过小米和苹果产品生产的例子来解释该模式。

为了弄清楚上面的结构，咱们使用具体的产品和工厂来表示上面的UML类图，能更加清晰的看出模式是如何演变的：

PC类：定义PC产品的接口(AbstractPC)

public interface PC {
    void make();
}

MiPC类：定义小米电脑产品(MIPC)

public class MiPC implements PC {
    public MiPC() {
        this.make();
    }
    @Override
    public void make() {
        // TODO Auto-generated method stub
        System.out.println("make xiaomi PC!");
    }
}

MAC类：定义苹果电脑产品(MAC)

public class MAC implements PC {
    public MAC() {
        this.make();
    }
    @Override
    public void make() {
        // TODO Auto-generated method stub
        System.out.println("make MAC!");
    }
}

下面须要修改工厂相关的类的定义：

AbstractFactory类：增长PC产品制造接口

public interface AbstractFactory {
    Phone makePhone();
    PC makePC();
}

XiaoMiFactory类：增长小米PC的制造（ConcreteFactory1）

public class XiaoMiFactory implements AbstractFactory{
    @Override
    public Phone makePhone() {
        return new MiPhone();
    }
    @Override
    public PC makePC() {
        return new MiPC();
    }
}

AppleFactory类：增长苹果PC的制造（ConcreteFactory2）

public class AppleFactory implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new IPhone();
    }
    @Override
    public PC makePC() {
        return new MAC();
    }
}

演示：

public class Demo {
    public static void main(String[] arg) {
        AbstractFactory miFactory = new XiaoMiFactory();
        AbstractFactory appleFactory = new AppleFactory();
        miFactory.makePhone();            // make xiaomi phone!
        miFactory.makePC();                // make xiaomi PC!
        appleFactory.makePhone();        // make iphone!
        appleFactory.makePC();            // make MAC!
    }
}

总结：

上面介绍的三种工厂模式有各自的应用场景，实际应用时能解决问题知足需求便可，可灵活变通，无所谓高级与低级。

此外不管哪一种模式，因为可能封装了大量对象和工厂建立，新加产品须要修改已定义好的工厂相关的类，所以对于产品和工厂的扩展不太友好，利弊须要权衡一下。