工厂模式

这次主要介绍的是三种与工厂有关的模式：简单工厂模式、工厂方法模式、抽象工厂模式。课件与源码点击这里。

不用工厂模式

这次我们以宝马车的生产来举例。当用户想要一辆宝马时，如果不用工厂，那么用户得自己先创造才能用：
车制造类：

public class BMW320 {
    public BMW320() {
        System.out.println("制造-->BMW320");
    }
}

主方法：

public class WithoutFactory {
    public static void main(String[] args) {
        BMW320 bmw320 = new BMW320();
    }
}

但是这样客户得自己生产宝马，客户得知道汽车的生产方法才行。但是现实生活都是由工厂来生产，客户只需要购买就可以，这样汽车的生产过程与用户就松耦合了。这样就引入了工厂模式。将车的生产过程都放在工厂中实现，用户只需传入想买的车即可。

简单工厂模式

下面看看简单工厂的写法：
定义一个BMW基类:

public class BMW {
    public BMW() {

    }
}

具体的汽车型号都继承自基类：

public class BMW320 extends BMW{
    public BMW320() {
        System.out.println("制造-->BMW320");
    }
}

public class BMW523 extends BMW{
    public BMW523(){
        System.out.println("制造-->BMW523");
    }
}

再建立一个工厂，通过用户传入的车的型号来生产汽车：

public class Factory {
    public BMW createBMW(String type){
        if (type.equals("BMW320")) {
            return new BMW320(); 
        }else if (type.equals("BMW523")){
            return new BMW523();
        }
        return null;
    }
}

最后是主方法：

public class SimpleFactory {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Factory factory = new Factory();
        BMW bmw320 = factory.createBMW("BMW320");
    }
}

简单工厂类的UML图如下：

简单工厂UML

但是在简单工厂模式中，如果要增加一种新的车型时，就需要在工厂类中增加相应的创建业务逻辑，如果增加的类型一多的话就会将工厂类变得臃肿，这时工厂方法模式出现了。

工厂方法模式

我们将每个车型都设置一个工厂，不同的工厂生产不同的车型。
工厂接口：

interface FactoryBWM {
    public BMW createBMW(); 
}

具体汽车生产工厂：

public class FactoryBMW320 implements FactoryBWM{
    @Override
    public BMW createBMW() {
        return new BMW320();
    }
}

主方法：

public class FactoryMethod {
    public static void main(String[] args) {
        FactoryBWM factoryBWM320 = new FactoryBMW320();
        factoryBWM320.createBMW();

        FactoryBWM factoryBWM523 = new FactoryBMW523();
        factoryBWM523.createBMW();
    }
}

简单工厂模式算工厂方法模式的一种特殊情况。

抽象工厂模式

最后再介绍抽象工厂模式。前面两种介绍的是一系列产品的制造，而抽象工厂则是同一种产品的制造。可以理解为前两种是横向的，抽象工厂是纵向的。比如：还是造宝马，有的空调带暖风，有的只能吹冷风；有的座椅是真皮，有的座椅是格布。而一般带暖风的空调得配格布座椅，而带冷风的空调配真皮座椅。

1. 空调：

    interface Aircondition {
        // 空调
    }
   
    public class AirconditionColdWind implements Aircondition{
        public AirconditionColdWind() {
            System.out.println("空调有冷风了");
        }
    }
   
    public class AirconditionWarmWind implements Aircondition{
        public AirconditionWarmWind() {
            System.out.println("空调有暖风了");
        }
    }

2. 座椅：

    interface Sofa {
        // 沙发
    }
   
    public class SofaOfGebb implements Sofa{
        public SofaOfGebb(){
            System.out.println("我的格布座椅");
        }
    }
   
    public class SofaOfHypoderm implements Sofa{
        public SofaOfHypoderm() {
            System.out.println("我的真皮座椅");
        }
    }

3. 产品线：

    interface AbstractProduce {
        public Aircondition createAircondition();
        public Sofa createSofa();
    }
   
    public class Condition1 implements AbstractProduce{
        // 搭配方案1: 冷风搭真皮
        @Override
        public Aircondition createAircondition() {
            return new AirconditionColdWind();
        }
   
        @Override
        public Sofa createSofa() {
            return new SofaOfHypoderm();
        }
    }
   
    public class Condition2 implements AbstractProduce{
        // 搭配方案2: 暖风搭格布
        @Override
        public Aircondition createAircondition() {
            return new AirconditionWarmWind();
        }
   
        @Override
        public Sofa createSofa() {
            return new SofaOfGebb();
        }
    }

4. 主方法：

    public class AbstractFactory {
        public static void main(String[] args) {
            AbstractProduce customProduce = new Condition1();
            customProduce.createAircondition();
            customProduce.createSofa();
   
            AbstractProduce customProduce2 = new Condition2();
            customProduce2.createAircondition();
            customProduce2.createSofa();
        }
    }

当需要创建的对象是一系列相互关联或相互依赖的产品族时，便可以使用抽象工厂模式。

在使用时，我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式，因为他们之间的演变常常是令人琢磨不透的。经常你会发现，明明使用的工厂方法模式，当新需求来临，稍加修改，加入了一个新方法后，由于类中的产品构成了不同等级结构中的产品族，它就变成抽象工厂模式了；而对于抽象工厂模式，当减少一个方法使的提供的产品不再构成产品族之后，它就演变成了工厂方法模式。所以，在使用工厂模式时，只需要关心降低耦合度的目的是否达到了。

原文地址：http://www.jianshu.com/p/2afa1d48e034