java常用设计模式-工厂模式（通俗易懂）

一、什么是工厂方法模式？

发现好多讲工厂方法模式的都不太对，既然研究了设计模式我们就要做到“知其然”，也要“知其所以然”。

工厂模式简单来说就是把一个对象某个特征抽象出来，利用java的多态特性让子类实现父类的这个方法，利用工厂类完成对子类具体方法的调用，整个过程工厂类类似生产产品的工厂，它决定生产什么产品，应该怎么生产。

（一）、工厂方法模式

比如，我们来创建一个汽车的接口，所有的汽车有一个功能，那就是run！（不能跑的车那还算车吗？）

public interface Car {
    //定义汽车的一个功能
    void run();
}

然后创建一个子类实现汽车的这个功能，比如第一个子类我们创建现在很火的国产品牌，比亚迪汽车。

public class BYDCar implements Car{
    @Override
    public void run() {
        System.out.println("我是电动汽车，我提速快！");
    }
}

然后有一天我们赚钱了，想换个有“面子”的车呢？再买一辆进口的吧！

public class TeslaCar implements Car {
    @Override
    public void run() {
        System.out.println("我刹得住！别尬黑=。=");
    }
}

接下来我们就需要一个生产汽车的工厂了，那么工厂生产的流程是什么呢？应该是只需要关注生产车本身，而不关注车是什么样子的，有什么功能，我们只需要知道生产的是汽车就行啦！ 这就需要一个抽象工厂类，定义一个生产汽车的抽象工厂

public abstract class AbstractCarFactory {
    /**
     *
     * @param c 参数必须是T类型
     * @param <T> Car的子类
     * @return 返回值必须是Car的子类
     */
    public abstract <T extends Car> T createCar(Class<T> c);
}

然后继承抽象工厂类，创建一个生产具体汽车的工厂类。

public class CarFactory extends AbstractCarFactory {
    @Override
    public <T extends Car> T createCar(Class<T> c) {
        //定义一个汽车
        Car car = null;
        try {
            car = (T) Class.forName(c.getName()).newInstance();
        } catch (Exception e) {
            System.out.println("汽车类型错误！");
        }
        return (T) car;
    }
}

最后就是生产环节了，我们定义一个工人来利用工厂生产汽车！

public class Worker {
    public static void main(String[] args) {
        AbstractCarFactory factory = new CarFactory();
        //第一次生产出了byd汽车！
        BYDCar bydCar = factory.createCar(BYDCar.class);
        bydCar.run();
        //第二次生产出特斯拉！
        TeslaCar teslaCar = factory.createCar(TeslaCar.class);
        teslaCar.run();
    }
}

运行结果：

（二）、简单工厂模式

简单工厂又叫静态工厂模式，是工厂方法模式的弱化版本；有时候我们可能一个模块只需要一个工厂类就行了，就不需要把工厂抽象出来，这样我们就可以把AbstractCarFactory 抽象类删了，只留下CarFactory 实现具体功能。
1、修改CarFactory ，修改createCar();为静态方法。

public class CarFactory {
    /*@Override
    public <T extends Car> T createCar(Class<T> c) {
        //定义一个汽车
        Car car = null;
        try {
            car = (T) Class.forName(c.getName()).newInstance();
        } catch (Exception e) {
            System.out.println("汽车类型错误！");
        }
        return (T) car;
    }*/
    public static <T extends Car> T createCar(Class<T> c) {
        //定义一个汽车
        Car car = null;
        try {
            car = (T) Class.forName(c.getName()).newInstance();
        } catch (Exception e) {
            System.out.println("汽车类型错误！");
        }
        return (T) car;
    }
}

2、调用工厂方法生产汽车。

public class Worker {
    public static void main(String[] args) {
        CarFactory carFactory = new CarFactory();
        //第一次生产出了byd汽车！
        BYDCar bydCar = carFactory.createCar(BYDCar.class);
        bydCar.run();
        //第二次生产出特斯拉！
        TeslaCar teslaCar = carFactory.createCar(TeslaCar.class);
        teslaCar.run();
    }
}

结果：

静态工厂的弊端：
违背了“开-闭”原则，如果要增加新的子类逻辑，工厂的方法必然也要修改，后期会造成逻辑太复杂，维护困难。

以上就是工厂方法模式的两种形式，因本人水平有限难免有错误，烦请指正批评。
下期预告：抽象工厂模式。