设计模式之：理解三种工厂模式原理

首先网上的各种理论感觉没有那么好理解，每个博客的术语也都千奇百怪，直接通过代码演示最直接，最好理解，然后你再想去看理论，就轻松的很了。核心思想就是：代替原来的new对象的方式，通过工厂去生成，看起来不是new而已。

1. 工厂模式

(1) 简单工厂模式（ 静态工厂模式 ）

在简单工厂模式中可以根据参数的不同返回不同的实例，这种方式最简单，只是进行了简单的封装，平时咱们也都用过类似的思想

步骤：定义规范接口类或父类 -> 子类实现 ->创建工厂类 ->over

public interface Car { //各自实现各自的
    void make();
}

public class AoDiCar implements Car{   //实现一
    public AoDiCar() {
        this.make();
    }
    @Override
    public void make() {
        System.out.println("奥迪车");
    }
}

public class BaoMaCar implements Car{   //实现二
    public BaoMaCar() {
        this.make();
    }
    @Override
    public void make() {
        System.out.println("宝马车");
    }
}

public class CarFactory {   //这就是所谓的工厂，按类型各自生成对应的类（就是if else）
    public Car makeCar(String type){
        if ("baoMa".equals(type)) {
            return new BaoMaCar();
        }
        if ("aoDi".equals(type)) {
            return new AoDiCar();
        }
        return null;
    }

}

public class TestFactory {  //测试用法，这就是所谓的工厂类
    public static void main(String[] args) {
        CarFactory factory = new CarFactory();
        Car baoMa = factory.makeCar("baoMa");
        Car aoDi = factory.makeCar("aoDi");
    }
}

是不是简单得很？既然有了这种工厂模式，为啥还会有下边的工厂方法模式呢？？

这就要从开闭原则说起了：官方术语我就不copy了，简单来说就是我现在要新加一个(特斯拉车)实现类，不要修改原来的逻辑。简单工厂模式这种就需要再CarFactory类中新添加 if else 进行判断。

因此引出下边这种工厂模式…

(2)工厂方法模式

简单来说。改进点就是每一个实现类都对应一个单独的工厂，A->AFactory，B->BFactory

Car、AoDiCar、BaoMaCar类保持不变

public interface AbstractFactory { //抽象工厂，其他的工厂需进行实现
    Car makeCar();
}

public class AoDiCarFactory implements AbstractFactory{ //AoDi工厂
    @Override
    public Car makeCar() {
        return new AoDiCar();
    }
}

public class BaoMaCarFactory implements AbstractFactory{ //BaoMa工厂
    @Override
    public Car makeCar() {
        return new BaoMaCar();
    }
}

-------------end----------------

使用方法：

public class TestFactory {
    public static void main(String[] args) {
        AbstractFactory aoDiCarFactory = new AoDiCarFactory();
        aoDiCarFactory.makeCar();

        AbstractFactory baoMaCarFactory = new BaoMaCarFactory();
        baoMaCarFactory.makeCar();
    }

}

这种方式要是新增(特斯拉)实现类，只需要创建单独的工厂，对之前的业务代码不会嵌入。第一种存在的问题解决，同时会发现类比第一种工厂模式多，结构也会更复杂。所以不存在绝对的哪种方式好，适合自己项目的就是好的，选的时候也不需要太纠结，各有各的好处。

2. 抽象工厂模式

个人感觉这种抽象工厂模式和工厂方法模式的界限不是很清楚，两者在代码结构上简单一变就会变成另一种模式。工厂方法模式针对的是一类产品，比如就是生产手机。而抽象工厂模式针对的是一个产品组，比如宝马，我既要生产车，又要生产手表等其他产品。

public interface Watch {  //新增其他类型的产品族
    void makeWatch();
}

public class AoDiWatch implements Watch {  //实现类一
    public AoDiWatch() {
        this.makeWatch();
    }
    @Override
    public void makeWatch() {
        System.out.println("奥迪手表");
    }
}

public class BaoMaWatch implements Watch {  //实现类二
    public BaoMaWatch() {
        this.makeWatch();
    }
    @Override
    public void makeWatch() {
        System.out.println("宝马手表");
    }
}

public interface AbstractFactory {  //抽象工厂
    Car makeCar();
    Watch makeWatch();
}

使用方法：

public class TestFactory {
    public static void main(String[] args) {
        AbstractFactory aoDiCarFactory = new AoDiCarFactory();
        aoDiCarFactory.makeCar();
        aoDiCarFactory.makeWatch();

        AbstractFactory baoMaCarFactory = new BaoMaCarFactory();
        baoMaCarFactory.makeCar();
        baoMaCarFactory.makeWatch();
    }
}

结束：

其实能看的出来抽象工厂模式和工厂方法模式差别不大的，抽象工厂模式新增一个其他类型的产品也需要修改之前的工厂逻辑的。A公司有1,2,3这三种产品，B公司也有1,2,3三种，这样的比较适合使用抽象工厂。单一产品的话就选择工厂方法模式或者简单工厂模式。。还是那句话不要局限说是那种模式，灵活运用这种思想即可。