工厂模式

工厂模式

工厂模式，顾名思义就是用来创建产品的一种设计模式，在面向对象的语言中，产品就是一个对象，那工厂就是用来创建对象的工具。那为什么需要工厂呢，有些对象的创建过程可能比较复杂，各种不同的对象交织在一起，利用工厂可以隐藏对象的创建过程，方便调用者的使用，符合迪米特法则。工厂模式属于创建型模式。

简单工厂模式

简单工厂模式，顾名思义这个工厂模式非常简单，所有产品都在一个工厂中创建。例如，有一个汽车工厂，无论是宝马汽车，还是奥迪汽车，都可以用一个汽车工厂创建出来，具体代码实例如下：

/**
 * 抽象的汽车接口
 */
public interface ICar {
    public void run();
}

public class AudiCar implements ICar {
    @Override
    public void run() {
        System.out.println("奥迪汽车开跑了......");
    }
}

public class BmwCar implements ICar {
    @Override
    public void run() {
        System.out.println("宝马汽车开跑了......");
    }
}

/**
 * 汽车工厂
 */
public class CarFactory {

    public static ICar create(Class<? extends ICar> clazz) {
        try {
            return clazz.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return null;
    }
}

public class Test {
    public static void main(String[] args) {
        ICar audiCar = CarFactory.create(AudiCar.class);
        audiCar.run();

        ICar bmwCar = CarFactory.create(BmwCar.class);
        bmwCar.run();
    }
}

测试结果：

奥迪汽车开跑了......
宝马汽车开跑了......

简单工厂模式，其实现过程非常简单，但是如果不同的产品类型有不同的创建过程，例如宝马汽车在创建实例时需要做百公里加速测试，只有百公里加速小于7s，才可以出场，而奥迪汽车需要做百公里刹车距离测试，只有百公里刹车距离小于30m，才可以出场。那这样，每增加一个新的产品就需要修改factory的create方法，不符合开闭原则。

工厂方法模式

针对简单工厂模式所有产品都用一个工厂创建的弊端，工厂方法模式则是为每种产品分配一个工厂，代码实例如下：

/**
 * 汽车工厂的抽象
 */
public interface ICarFactory {
    public ICar create();
}

/**
 * 奥迪汽车工厂，只生产奥迪汽车
 */
public class AudiCarFactory implements ICarFactory {
    @Override
    public ICar create() {
        // ...省略奥迪汽车的创建过程
        return new AudiCar();
    }
}

/**
 * 宝马汽车工厂，只生产宝马汽车
 */
public class BmwCarFactory implements ICarFactory {
    @Override
    public ICar create() {
        // ...省略宝马汽车的创建过程
        return new BmwCar();
    }
}

public class Test {
    public static void main(String[] args) {
        ICarFactory carFactory = new AudiCarFactory();
        ICar audiCar = carFactory.create();
        audiCar.run();

        carFactory = new BmwCarFactory();
        ICar bmwCar = carFactory.create();
        bmwCar.run();
    }
}

测试结果：

奥迪汽车开跑了......
宝马汽车开跑了......

若产品进一步扩充，汽车不止有宝马或奥迪等品牌，还有普通汽车和SUV汽车等系列，这个时候就需要使用另外一种工厂模式，抽象工厂模式来实现

抽象工厂模式

若一个产品的创建需要多个维度，例如品牌、系列、价格等多维度，则需要抽象工厂模式来实现，具体代码实例如下：

/**
 * 汽车抽象
 */
public interface ICar {
    // 描述
    public void discriber();
}

/**
 * 普通汽车抽象
 */
public interface INormalCar extends ICar{
}

/**
 * SUV汽车抽象
 */
public interface ISuvCar extends ICar{
}

/**
 * 奥迪普通汽车
 */
public class AudiNormalCar implements INormalCar {
    @Override
    public void discriber() {
        System.out.println("我是奥迪普通汽车!!!");
    }
}

/**
 * 奥迪SUV汽车
 */
public class AudiSuvCar implements ISuvCar {

    @Override
    public void discriber() {
        System.out.println("我是奥迪SUV汽车！！！");
    }
}

/**
 * 宝马普通汽车
 */
public class BmwNormalCar implements INormalCar {
    @Override
    public void discriber() {
        System.out.println("我是宝马普通汽车！！！");
    }
}

/**
 * 宝马SUV汽车
 */
public class BmwSuvCar implements ISuvCar {
    @Override
    public void discriber() {
        System.out.println("我是宝马SUV汽车！！！");
    }
}

/**
 * 抽象工厂
 */
public abstract class AbstractCarFactory {

    public abstract INormalCar createNormalCar();

    public abstract ISuvCar createSuvCar();

}

/**
 * 奥迪汽车工厂
 */
public class AudiCarFactory extends AbstractCarFactory {
    @Override
    public INormalCar createNormalCar() {
        // 生产奥迪普通汽车
        return new AudiNormalCar();
    }

    @Override
    public ISuvCar createSuvCar() {
        // 生产奥迪SUV汽车
        return new AudiSuvCar();
    }
}

/**
 * 宝马汽车工厂
 */
public class BmwCarFactory extends AbstractCarFactory {
    @Override
    public INormalCar createNormalCar() {
        // 生产宝马普通汽车
        return new BmwNormalCar();
    }

    @Override
    public ISuvCar createSuvCar() {
        // 生产宝马SUV汽车
        return new BmwSuvCar();
    }
}

public class Test {
    public static void main(String[] args) {
        AbstractCarFactory audiCarFactory = new AudiCarFactory();
        INormalCar audiNormalCar = audiCarFactory.createNormalCar();
        ISuvCar audiSuvCar = audiCarFactory.createSuvCar();

        AbstractCarFactory bmwCarFactory = new BmwCarFactory();
        INormalCar bmwNormalCar = bmwCarFactory.createNormalCar();
        ISuvCar bmwSuvCar = bmwCarFactory.createSuvCar();


        audiNormalCar.discriber();
        audiSuvCar.discriber();
        bmwNormalCar.discriber();
        bmwSuvCar.discriber();
    }
}

测试结果：

我是奥迪普通汽车！！！
我是奥迪SUV汽车！！！
我是宝马普通汽车！！！
我是宝马SUV汽车！！！