设计模式——工厂模式

概述：工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。 

分类：
简单工厂模式（Simple Factory） 
工厂方法模式（Factory Method） 
抽象工厂模式（Abstract Factory）

简单工厂（Simple Factory）

又叫静态工厂，是工厂模式三中状态中结构最为简单的。主要有一个静态方法，用来接受参数，并根据参数来决定返回实现同一接口的不同类的实例。

例子：

汽车接口：

public interface Car {
    public void run();
}

BYD汽车：

public class BydCar implements Car {

    public BydCar() {
        System.out.println("比亚迪汽车被创建了");
    }

    @Override
    public void run() {
        System.out.println("比亚迪汽车run...");
    }
}

GEELY汽车：

public class GeelyCar implements Car {

    public GeelyCar() {
        System.out.println("吉利汽车被创建了");
    }

    @Override
    public void run() {
        System.out.println("吉利汽车run...");
    }
}

汽车工厂：

public class CarFactory {

    private final static CarFactory carFactory = new CarFactory();

    public static CarFactory newInstance() {
        return carFactory;
    }

    public Car create(String type) {

        if("BYD".equals(type)) {
            return new BydCar();
        } else if("GEELY".equals(type)) {
            return new GeelyCar();
        } else {
            throw new RuntimeException("不支持创建该汽车");
        }

    }
}

测试类：

public class Test {

    public static void main(String[] args) {
        CarFactory carFactory = CarFactory.newInstance();
        Car car1 = carFactory.create("BYD");
        Car car2 = carFactory.create("GEELY");
        car1.run();
        car2.run();
    }
}

工厂方法（Factory Method）

上面的代码告诉我们，简单工厂并不简单，它是整个模式的核心，一旦他出了问题，整个模式都将受影响而不能工作，为了降低风险和为日后的维护、扩展做准备，我们需要对它进行重构，引入工厂方法。

例子：

产品接口：

public interface Product {}

工厂接口：

public interface Factory {
    public Product create();
}

冰箱产品：

public class Icebox implements Product{
    public Icebox(){
        System.out.println("冰箱被制造了");
    }
}

空调产品：

public class AirCondition implements Product{
    public AirCondition(){
        System.out.println("空调被制造了");
    }
}

洗衣机产品：

public class Washer implements Product{
    public Washer(){
        System.out.println("洗衣机被制造了");
    }
}

冰箱工厂：

public class IceboxFactory implements Factory {
    @Override
    public Product create() {
        return new Icebox();
    }
}

空调工厂：

public class AirConditionFactory implements Factory {
    @Override
    public Product create() {
        return new AirCondition();
    }
}

洗衣机工厂：

public class WasherFactory implements Factory {
    @Override
    public Product create() {
        return new Washer();
    }
}

测试类：

public class Test {

    public static void main(String[] args) {
        AirConditionFactory factory1 = new AirConditionFactory();
        IceboxFactory factory2 = new IceboxFactory();
        WasherFactory factory3 = new WasherFactory();
        factory1.create();
        factory2.create();
        factory3.create();
    }
}

       从上面创建产品对象的代码可以看出，工厂方法和简单工厂的主要区别是，简单工厂是把创建产品的职能都放在一个类里面，而工厂方法则把不同的产品放在实现了工厂接口的不同工厂类里面，这样就算其中一个工厂类出了问题，其他工厂类也能正常工作，互相不受影响，以后增加新产品，也只需要新增一个实现工厂接口工厂类，就能达到，不用修改已有的代码。但工厂方法也有他局限的地方，那就是当面对的产品有复杂的等级结构的时候，例如，工厂除了生产家电外产品，还生产手机产品，这样一来家电是手机就是两大产品家族了，这两大家族下面包含了数量众多的产品，每个产品又有多个型号，这样就形成了一个复杂的产品树了。如果用工厂方法来设计这个产品家族系统，就必须为每个型号的产品创建一个对应的工厂类，当有数百种甚至上千种产品的时候，也必须要有对应的上百成千个工厂类，这就出现了传说的类爆炸，对于以后的维护来说，简直就是一场灾难.....

抽象工厂模式（Abstract Factory）

    超链接到抽象工厂模式文章