设计模式之工厂模式

一、什么是工厂模式

    工厂模式是用来创建对象的一种最常用的设计模式。是用工厂方法代替new操作的一种模式。我们不暴露创建对象的具体逻辑，而是将逻辑封装在一个函数中，那么这个函数就可以被视为一个工厂。

二、工厂模式的分类

简单工厂模式，工厂方法模式，抽象方法模式

简单工厂 ：用来生产同一等级结构中的任意产品。（不支持拓展增加产品）

工厂方法 ：用来生产同一等级结构中的固定产品。（支持拓展增加产品）

抽象工厂 ：用来生产不同产品族的全部产品。（不支持拓展增加产品；支持增加产品族）

三、工厂方法模式

1、描述

提供一个用于创建对象的接口(工厂接口)，让其实现类(工厂实现类)决定实例化哪一个类(产品类)，并且由该实现类创建对应类的实例

2、模式作用

可以一定程度上解耦，消费者和产品实现类隔离开，只依赖产品接口(抽象产品)，产品实现类如何改动与消费者完全无关。

可以一定程度增加扩展性，若增加一个产品实现，只需要实现产品接口，修改工厂创建产品的方法，消费者可以无感知（若消费者不关心具体产品是什么的情况）。
可以一定程度增加代码的封装性、可读性。清楚的代码结构，对于消费者来说很少的代码量就可以完成很多工作。

3、代码

Car：产品接口

package factory.v1;

/**
 * @Package: factory.v1
 * @ClassName: Car
 * @Author: tanp
 * @Description: 工厂设计模式的产品接口
 * @Date: 2020/10/22 15:03
 */
public interface Car {
    void makeCar();
}

BlueCar ：实现产品接口的实现类

package factory.v1;

/**
 * @Package: factory.v1
 * @ClassName: BlueCar
 * @Author: tanp
 * @Description: ${description}
 * @Date: 2020/10/22 15:06
 */
public class BlueCar implements Car {
    @Override
    public void makeCar() {
        System.out.println(
                "make a blue car"
        );
    }
}

redCar ：实现产品接口的实现类

package factory.v1;

/**
 * @Package: factory.v1
 * @ClassName: RedCar
 * @Author: tanp
 * @Description: ${description}
 * @Date: 2020/10/22 15:05
 */
public class RedCar implements Car{
    @Override
    public void makeCar() {
        System.out.println(
                "make a red car"
        );
    }
}

CarFactory：工厂接口

package factory.v1;

/**
 * @Package: factory.v1
 * @ClassName: CarFactory
 * @Author: tanp
 * @Description: 提供一个用于创建对象的接口(工厂接口)，让其实现类(工厂实现类)决定实例化哪一个类(产品类)，并且由该实现类创建对应类的实例
 * @Date: 2020/10/22 15:07
 */
public interface CarFactory {
    Car makeCars(String type);
}

CarFactoryImpl：工厂接口实现类，在该类里决定实例化哪一个类，并返回新创建的实例

package factory.v1;

/**
 * @Package: factory.v1
 * @ClassName: CarFactoryImpl
 * @Author: tanp
 * @Description: ${description}
 * @Date: 2020/10/22 15:08
 */
public class CarFactoryImpl implements CarFactory {
    @Override
    public Car makeCars(String type) {
        Car car;
        if(type.equals("red")){
            car = new  RedCar();
        }else{
            car = new BlueCar();
        }
        return car;
    }
}

CarMain： main方法所在类，模拟消费者调用工厂接口

package factory.v1;

/**
 * @Package: factory.v1
 * @ClassName: CarViMain
 * @Author: tanp
 * @Description: main方法，模拟消费者
 * @Date: 2020/10/22 15:32
 */
public class CarViMain {
    public static void main(String[] args) {
        //消费者只知道有一个汽车工厂
        CarFactory carFactory = new CarFactoryImpl();
        //我需要一辆car
        Car car;
        //我需要一辆什么颜色的car，具体car如何制作跟我消费者无任何关系，实现解耦
        car = carFactory.makeCars("red");
        car.makeCar();
        car = carFactory.makeCars("blue");
        car.makeCar();
    }
}

以上的所有代码就是工厂方法模式的demo案例代码

四、简单工厂模式

简单工厂模式的代码相对于工厂方法模式的代码就是少了CarFactory工厂接口，直接在工厂实现类上新建实例，代码就不粘贴了

五、抽象工厂模式

1、描述

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

2、模式作用

系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。用来生产不同产品族的全部产品。在有多个业务品种、业务分类时使用

3、代码

car：产品接口1，多个产品中的car产品

package factory.v2;

/**
 * @Package: factory.v2
 * @ClassName: Car
 * @Author: tanp
 * @Description: 抽象工厂设计模式的产品接口1
 * @Date: 2020/10/22 16:32
 */
public interface Car {
    void makeCar();
}

package factory.v2;

/**
 * @Package: factory.v2
 * @ClassName: BlueCar
 * @Author: tanp
 * @Description: ${description}
 * @Date: 2020/10/22 16:54
 */
public class BlueCar implements Car{
    @Override
    public void makeCar() {
        System.out.println(
                "make blue car"
        );
    }
}

package factory.v2;

/**
 * @Package: factory.v2
 * @ClassName: RedCar
 * @Author: tanp
 * @Description: ${description}
 * @Date: 2020/10/22 16:53
 */
public class RedCar implements Car{
    @Override
    public void makeCar() {
        System.out.println(
                "make red car"
        );
    }
}

MotoCar：产品接口2，多个产品中的MotoCar

package factory.v2;

/**
 * @Package: factory.v2
 * @ClassName: MotoCar
 * @Author: tanp
 * @Description: ${description}
 * @Date: 2020/10/22 16:32
 */
public interface MotoCar {
    void makeMotoCar();
}

package factory.v2;

/**
 * @Package: factory.v2
 * @ClassName: BlueMotoCar
 * @Author: tanp
 * @Description: ${description}
 * @Date: 2020/10/22 17:16
 */
public class BlueMotoCar implements MotoCar{
    @Override
    public void makeMotoCar() {
        System.out.println(
                "make bule motocar"
        );
    }
}

package factory.v2;

/**
 * @Package: factory.v2
 * @ClassName: RedMotoCar
 * @Author: tanp
 * @Description: ${description}
 * @Date: 2020/10/22 16:55
 */
public class RedMotoCar implements MotoCar {
    @Override
    public void makeMotoCar() {
        System.out.println(
                "make red motocar"
        );
    }
}

factory:工厂接口，里面生产两种产品

package factory.v2;

/**
 * @Package: factory.v2
 * @ClassName: Factory
 * @Author: tanp
 * @Description: ${description}
 * @Date: 2020/10/22 17:31
 */
public interface Factory {
    Car makeCar(String type);
    MotoCar makeMotoCar(String type);
}

Carfactory；car的工厂实现类，用来实现生产car的产品

package factory.v2;


/**
 * @Package: factory.v2
 * @ClassName: CarFactory
 * @Author: tanp
 * @Description: ${description}
 * @Date: 2020/10/22 17:34
 */
public class CarFactory implements Factory{
    @Override
    public Car makeCar(String type) {
        Car car;
        if(type.equals("red")){
            car = new RedCar();
        }else{
            car = new BlueCar();
        }
        return car;
    }

    @Override
    public MotoCar makeMotoCar(String type) {
        return null;
    }
}

MotoFactory：MotoCar的工厂实现类，用来实现生产MotoCar

package factory.v2;

/**
 * @Package: factory.v2
 * @ClassName: MotoCarFactory
 * @Author: tanp
 * @Description: ${description}
 * @Date: 2020/10/22 17:37
 */
public class MotoCarFactory implements Factory {
    @Override
    public Car makeCar(String type) {
        return null;
    }

    @Override
    public MotoCar makeMotoCar(String type) {
        MotoCar motoCar;
        if(type.equals("red")){
            motoCar = new RedMotoCar();
        }else{
            motoCar = new BlueMotoCar();
        }
        return motoCar;
    }
}

FactoryProduct :用来选择你需要的工厂实现类

package factory.v2;

/**
 * @Package: factory.v2
 * @ClassName: FactoryProduct
 * @Author: tanp
 * @Description: ${description}
 * @Date: 2020/10/22 17:42
 */
public class FactoryProduct {
    public static Factory getFactory(String type){
        Factory factory;
        if("car".equals(type)){
            factory = new CarFactory();
        }else{
            factory = new MotoCarFactory();
        }
        return factory;
    }
}

main方法所在类，模拟消费者

package factory.v2;

/**
 * @Package: factory.v2
 * @ClassName: DemoMain
 * @Author: tanp
 * @Description: main方法，模拟消费者
 * @Date: 2020/10/22 17:48
 */
public class DemoMain {
    public static void main(String[] args) {
        //消费者只知道有一个汽车工厂的产品，可以在汽车工厂产品里获取生产对应汽车的工厂
        Factory factory = FactoryProduct.getFactory("car");
        //汽车工厂获取红色汽车
        Car car = factory.makeCar("red");
        car.makeCar();
        //从汽车工厂产品里获取摩托车工厂
        Factory factory1 = FactoryProduct.getFactory("motocar");
        //摩托车工厂获取蓝色摩托车
        MotoCar motoCar = factory1.makeMotoCar("blue");
        motoCar.makeMotoCar();
    }
}

六、工厂模式的作用

解耦：把对象的创建和使用的过程分开

降重：工厂模式可以降低代码重复。如果创建对象B的过程都很复杂，需要一定的代码量，而且很多地方都要用到，那么就会有很多的重复代码。

减少失误：工厂管理了对象的创建逻辑，使用者并不需要知道具体的创建过程，只管使用即可，减少了使用者因为创建逻辑导致的错误