设计模式学习笔记：工厂模式（Factory）

成年人的世界，似乎只有赚到足够的钱，才能过上简单、安逸、自由的生活，才能让自己获得更有底气些。所以，多一些努力吧，少点功夫矫情。

一、工厂模式介绍

工厂模式属于设计模式中的创建型模式。工厂模式提供了一种最佳的创建对象的方式。工厂模式从简单到复杂有三种：简单工厂、工厂方法、抽象工厂。

三种工厂模式的简单区分：

简单工厂：根据传递给工厂类的不同参数创建不同的产品。例如：给生产汽车的工厂传递不同的参数生产不同的汽车。

工厂方法：根据自己的需要使用不同的工厂来生产产品。例如：我要一辆奥迪汽车，那么就找奥迪汽车的工厂来生产奥迪汽车。

抽象工厂：根据自己的需要使用不同的工厂来生产同一个产品族的多个产品。例如：我要一辆奥迪汽车，还要奥迪牌的手机（假如奥迪生产手机），那么就找奥迪的工厂来生产奥迪汽车和奥迪手机。

二、工厂模式的三种不同实现

1、简单工厂模式

顾名思义，简单工厂模式真的很简单，就是对对象创建做了一层简单的封装，根据不同的参数创建不同的对象。

例如：汽车工厂生产不同的汽车。类图如下：

代码示例：

汽车的接口：

/**
 * 汽车接口
 * @author ZhengNC
 * @date 2020/7/13 16:32
 */
public interface Car {
    /**
     * 打印汽车的信息
     */
    void carInfo();
}

奥迪汽车：

public class AudiCar implements Car {
    @Override
    public void carInfo() {
        System.out.println("奥迪汽车");
    }
}

奔驰汽车：

public class BenzCar implements Car {
    @Override
    public void carInfo() {
        System.out.println("奔驰汽车");
    }
}

宝马汽车：

public class BMWCar implements Car {
    @Override
    public void carInfo() {
        System.out.println("宝马汽车");
    }
}

简单汽车工厂：

/**
 * 简单汽车共产
 * @author ZhengNC
 * @date 2020/7/13 16:33
 */
public class CarFactory {

    public static Car getCar(String type){
        Car car = null;
        switch (type){
            case "audi":
                car = new AudiCar();
                break;
            case "benz":
                car = new BenzCar();
                break;
            case "BMW":
                car = new BMWCar();
                break;
            default:
                System.out.println("没有此类型的汽车");
                break;
        }
        return car;
    }
}

测试简单汽车工厂：

/**
 * 测试简单工厂
 *
 * @author ZhengNC
 * @date 2020/7/13 16:46
 */
public class TestSimpleFactory {

    public static void main(String[] args) {
        Car car1 = CarFactory.getCar("audi");
        car1.carInfo();
        Car car2 = CarFactory.getCar("benz");
        car2.carInfo();
        Car car3 = CarFactory.getCar("BMW");
        car3.carInfo();
    }
}

2、工厂方法模式

简单工厂的方式存在一个比较大的问题，那就是每当新增一种汽车的时候都要修改工厂类，去实现生产新增的汽车的功能，这违反了设计模式中的开闭原则，因此产生了工厂方法模式，工厂方法模式将工厂抽象出一个接口，每种汽车使用不同的工厂去生产，这样每当新增一种汽车的时候就不用改原来的工厂的代码，而是直接新建一个工厂类就可以了。

还使用生产汽车的例子来讲解。类图如下：

代码示例：

其中 汽车的接口、奔驰汽车、宝马汽车、奥迪汽车代码实现与简单工厂一致。

汽车工厂接口：

/**
 * 工厂接口
 *
 * @author ZhengNC
 * @date 2020/7/13 16:33
 */
public interface CarFactory {

    Car getCar();
}

奔驰汽车工厂：

public class BenzCarFactory implements CarFactory {
    @Override
    public Car getCar() {
        return new BenzCar();
    }
}

宝马汽车工厂：

public class BMWCarFactory implements CarFactory {
    @Override
    public Car getCar() {
        return new BMWCar();
    }
}

奥迪汽车工厂：

public class AudiCarFactory implements CarFactory {
    @Override
    public Car getCar() {
        return new AudiCar();
    }
}

测试工厂方法模式：

/**
 * 测试工厂方法模式
 *
 * @author ZhengNC
 * @date 2020/7/13 17:12
 */
public class TestMethodFactory {

    public static void main(String[] args) {
        //奥迪工厂
        CarFactory carFactory = new AudiCarFactory();
        //生产奥迪汽车
        Car car = carFactory.getCar();
        car.carInfo();

        //奔驰工厂
        CarFactory carFactory1 = new BenzCarFactory();
        //生产奔驰汽车
        Car car1 = carFactory1.getCar();
        car1.carInfo();

        //宝马工厂
        CarFactory carFactory2 = new BMWCarFactory();
        //生产宝马汽车
        Car car2 = carFactory2.getCar();
        car2.carInfo();
    }
}

3、抽象工厂模式

简单工厂模式和工厂方法模式都是只生产一种产品，如果需要生产多种产品怎么办呢？抽象工厂模式可以生产一个产品族里的多种产品。

例如我想要一辆奥迪汽车，还要一部奥迪手机（假如奥迪生产手机）。设计类图如下：

代码示例：

其中 汽车的接口、奔驰汽车、奥迪汽车代码实现与简单工厂一致。

手机的接口：

/**
 * 手机接口
 *
 * @author ZhengNC
 * @date 2020/7/13 17:34
 */
public interface Phone {

    /**
     * 打印手机信息
     */
    void phoneInfo();
}

奥迪手机：

public class AudiPhone implements Phone{
    @Override
    public void phoneInfo() {
        System.out.println("奥迪牌手机");
    }
}

奔驰手机：

public class BenzPhone implements Phone {
    @Override
    public void phoneInfo() {
        System.out.println("奔驰牌手机");
    }
}

手机工厂接口：

/**
 * 手机工厂接口
 *
 * @author ZhengNC
 * @date 2020/7/13 17:52
 */
public interface PhoneFactory {

    Phone getPhone();
}

汽车工厂接口：

/**
 * 汽车工厂接口
 *
 * @author ZhengNC
 * @date 2020/7/13 16:33
 */
public interface CarFactory {

    Car getCar();
}

抽象工厂抽象类：

/**
 * 抽象工厂 抽象类
 *
 * @author ZhengNC
 * @date 2020/7/13 17:56
 */
public abstract class AbstractFactory implements CarFactory, PhoneFactory {
}

奔驰产品工厂：

/**
 * 奔驰产品工厂
 *
 * @author ZhengNC
 * @date 2020/7/13 17:11
 */
public class BenzFactory extends AbstractFactory {
    @Override
    public Car getCar() {
        return new BenzCar();
    }

    @Override
    public Phone getPhone() {
        return new BenzPhone();
    }
}

奥迪产品工厂：

/**
 * 奥迪产品工厂
 *
 * @author ZhengNC
 * @date 2020/7/13 17:10
 */
public class AudiFactory extends AbstractFactory {
    @Override
    public Car getCar() {
        return new AudiCar();
    }

    @Override
    public Phone getPhone() {
        return new AudiPhone();
    }
}

测试抽象工厂：

/**
 * 测试抽象工厂
 *
 * @author ZhengNC
 * @date 2020/7/13 17:54
 */
public class TestAbstractFactory {

    public static void main(String[] args) {
        //创建奥迪工厂
        AbstractFactory factory = new AudiFactory();
        //奥迪工厂生产汽车
        Car car = factory.getCar();
        //奥迪工厂生产手机
        Phone phone = factory.getPhone();
        car.carInfo();
        phone.phoneInfo();

        //创建奔驰工厂
        AbstractFactory factory1 = new BenzFactory();
        //奔驰工厂生产汽车
        Car car1 = factory1.getCar();
        //奔驰工厂生产手机
        Phone phone1 = factory1.getPhone();
        car1.carInfo();
        phone1.phoneInfo();
    }
}

三、总结

三种工厂的设计模式复杂度是随着抽象的程度逐渐升高的，在实际运用中要根据场景选择合适的工厂设计模式，不是越复杂的就越好。