当我们聊工厂时，我们在聊什么？工厂模式 Factory。

一、工厂模式理解

怎么理解工厂模式？ 简单来说，就是将类的创建过程转移到工厂类中进行。
如果我们的类的初始化比较复杂，或者说有不同品类的实现，都可以考虑使用工厂模式。
工厂，顾名思义就是生产类的地方，将类的生产移交给工厂更方便扩展和管理。

二、分类

通常的，工厂模式又被分为了 3 类：

1. 简单工厂（静态工厂）
2. 工厂方法
3. 抽象工厂

我们从 AbstractFactory 的纬度来区分一下这三种的不同

1. 简单工厂

简单工厂没有 AbstractFactory ，没有进行工厂的抽象，其直接根据不同的名称生成不同的实体类，虽然不满足开闭原则，但我觉得用起来简单还爽，开发够用即可。

2. 工厂方法

工厂方法会抽象出 AbstractFactory ，每类产品都会实现一个工厂并继承 AbstractFactory ，其针对的是单一的产品，比如对于交通工具，我们可以有 自行车工厂，汽车工厂，飞机工厂等。

3. 抽象工厂

抽象工厂 是 工厂方法的进阶 ，其实来说区别不大，只是抽象工厂针对的更广泛，其生产的是产品族。比如 对于交通工具我们还有驾驶人，对于驾驶人我们还有穿着的时装，这个时候就产生了产品族：交通工具、驾驶人员、时装。 那么针对这一打产品进行统一的生产就是我们所说的抽象工厂。

三、举个例子

又到了举例子环节，同样，既然分了三类我们就举三个例子，其实来说就是一个升级的过程。

那么仍然以 交通工具 为例：

简单工厂实现：

首先准备好交通工具的一系列实体类：

/**
 * @description: 交通工具
 **/
public abstract class Vehicle {
    public abstract void go();
}

public class Car extends Vehicle{
    @Override
    public void go() {
        System.out.println("这是辆汽车在跑");
    }
}

public class Plane extends Vehicle{
    @Override
    public void go() {
        System.out.println("这是飞机在飞");
    }
}

public class Bicycle extends Vehicle{
    @Override
    public void go() {
        System.out.println("骑行的自行车");
    }
}

实现简单工厂

public class SimpleFactory {

    public static Vehicle createVehicle(String name) {
        switch (name) {
            case "car":
                return new Car();
            case "plane":
                return new Plane();
            case "bicycle":
                return new Bicycle();
            default:
                return null;
        }
    }
}

使用：

public class Main {

    public static void main(String[] args) {

        Vehicle vehicle=SimpleFactory.createVehicle("car");
        vehicle.go();
    }

}

很方便的我们根据不同的 name 进行了交通工具的生产，不同的交通工具传不同的 name 就可以了

基于简单工厂改为工厂方法

工厂方法实现

抽象工厂类

public abstract class AbstractVehicleFactory {
    public abstract Vehicle createVehicle();
}

public class BicycleFactory extends AbstractVehicleFactory{
    @Override
    public Vehicle createVehicle() {
        System.out.println("我创建自行车的时候搞了很多事情");
        return new Bicycle();
    }
}

public class CarFactory extends AbstractVehicleFactory{
    @Override
    public Vehicle createVehicle() {
        System.out.println("我创建汽车的时候进行了一系列精密操作");
        return new Car();
    }
}

public class PlanFactory extends AbstractVehicleFactory{
    @Override
    public Vehicle createVehicle() {
        System.out.println("我创建飞机的时候进行了一系列精密操作");
        return new Plane();
    }
}

使用

public class Main {

    public static void main(String[] args) {
        AbstractVehicleFactory factory = new PlanFactory();
        Vehicle vehicle = factory.createVehicle();
        vehicle.go();
    }
}

当然我们在创建工厂的时候也可以读取配置文件配置进行不同的创建，类似于简单工厂的 case 方法。

抽象工厂方法

我们之前说过，抽象工厂 和 工厂方法的区别在于前者是生产 一系列产品 后者是 单一的品类。其实很好理解，只是将创建控制的范围进行了扩大而已

为此我们需要扩展我们的产品一族：
新增衣服：

public abstract class Clothes {
    public abstract void shining();
}

public class Jacket extends Clothes{
    @Override
    public void shining() {
        System.out.println("夹克发出了褐色的光");
    }
}

public class ShortSleeve extends Clothes{
    @Override
    public void shining() {
        System.out.println("短袖发出了白色的光");
    }
}

public class Windbreaker extends Clothes{

    @Override
    public void shining() {
        System.out.println("风衣发出了黑色的荣光");
    }
}

新增角色：

public abstract class Character {
    public abstract void whoIsThat();
}

public class CommonHuman extends Character{
    @Override
    public void whoIsThat() {
        System.out.println("我是普通人");
    }
}

public class LongAT extends Character{
    @Override
    public void whoIsThat() {
        System.out.println("我是龙傲天");
    }
}

public class ZhangSan extends Character
{
    @Override
    public void whoIsThat() {
        System.out.println("我是张三");
    }
}

抽象出生产一族的工厂：

public abstract class AbstractFactory {

    public abstract Character createCharacter();

    public abstract Clothes createClothes();

    public abstract Vehicle createVehicle();
}

public class CommonHumanFactory extends AbstractFactory{


    @Override
    public Character createCharacter() {
        return new CommonHuman();
    }

    @Override
    public Clothes createClothes() {
        return new Jacket();
    }

    @Override
    public Vehicle createVehicle() {
        return new Car();
    }
}

public class LongATFactory extends AbstractFactory{


    @Override
    public Character createCharacter() {
        return new LongAT();
    }

    @Override
    public Clothes createClothes() {
        return new Windbreaker();
    }

    @Override
    public Vehicle createVehicle() {
        return new Plane();
    }
}

public class ZhangSanFactory extends AbstractFactory{

    @Override
    public Character createCharacter() {
        return new ZhangSan();
    }

    @Override
    public Clothes createClothes() {
        return new ShortSleeve();
    }

    @Override
    public Vehicle createVehicle() {
        return new Bicycle();
    }
}

使用：

public class Main {
    public static void main(String[] args) {
        AbstractFactory abstractFactory=new LongATFactory();
        Character character=abstractFactory.createCharacter();
        Vehicle vehicle=abstractFactory.createVehicle();
        Clothes clothes=abstractFactory.createClothes();
        character.whoIsThat();
        vehicle.go();
        clothes.shining();
    }
}

四、总结

工厂模式，习惯上分成了三种：

简单工厂模式、工厂方法模式、抽象工厂模式。

区别其实很简单：

1. 简单工厂只有一个工厂
2. 工厂方法对工厂进行了抽象，进行单一的类生产
3. 抽象工厂抽象了产品一族的工厂，生产一族类绑定产品

使用工厂模式的有点在于，其屏蔽了类底层的复杂创建过程，并且可以统一进行生产，流程更加易于管理，对拓展开放，对修改关闭，符合开闭原则。

在日常开发中，如果遇到较为复杂的一系列类的定制过程，就可以考虑使用工厂模式来优化你的代码。

对于上面三种区分，很多人应该很好奇，那个好那个坏？

其实真正的开发中并无好坏之分，合适，好用，就是最好的。同样的各类直接也可以结合使用，灵活运用方法才是根本之道。我是 dying 搁浅，希望本文对你有所帮助。

同时 欢迎添加个人微信 dyinggq 一起交流学习~~

我是 dying 搁浅 ，我始终期待与你的相遇。无论你是否期待，潮涨潮落，我仅且就在这里…

我们下期再见~