一、什么是工厂模式

1.概念

工厂模式的设计思想是提供一个工厂，这个工厂会将我们想要的对象实例做出一定的规范化，也省去了创建这个类的麻烦。

2.跟构建者模式的区别

构建者模式是针对「一个类」，而工厂模式则针对「多个类」（实现同一个接口的） 构建者模式是「向类的构造方法传入一个对象进行创建」的，工厂模式是直接「创建一个对象」，当然工厂模式内部也可以套用构建者模式来简化对象的创建。

3.工厂模式的使用场景

1. 「有很多类似的类，但我们只需要其中的一个」。像MyBatis中的日志工厂，日志类有很多，但是我们之需要一个，MyBatis的日志工厂就会根据我们的需求来创建日志类实例，或者创建默认日志类实例。
2. 「创建过程比较麻烦」。

4.优点

1. 「扩展性高」。像创建新的类，直接创建新的工厂即可。
2. 「使创建过程透明化」。在使用工厂时，不需要考虑它的创建过程，直接使用即可。

5.缺点

1. 「工厂的创建步骤麻烦」。
2. 「增加系统的复杂度」。创建个对象绕来绕去，头都晕了。
3. 「依赖性过高」。每个工厂和对应的类之间依赖性太高了，修改一个类，也要修改工厂。创建一个类，也要创建一个工厂。

6.原则

“+”代表遵守，“-”代表不遵守或者不相关

原则 开放封闭 单一职责 迪米特 里氏替换 依赖倒置 接口隔离 合成复用 + + + - + + -

二、工厂模式的分类

1.简单工厂

「概念」

简单工厂就比较简单了，它并没有一个类对应一个工厂，而是都「由一个工厂来控制类的创建」。

「代码」

package factory;

/**
 * @author xxj
 * 简单工厂
 */
public class SimpleFactory {
    public Car create(String car){
        if (car=="BENZ"){
            return new BENZCar();
        }else if (car=="BMW"){
            return new BMWCar();
        }else {
            return null;
        }
    }
    public class BENZCar implements Car{
        @Override
        public void draw() {
            System.out.println("BENZ在跑");
        }
    }
    public class BMWCar implements Car{

        @Override
        public void draw() {
            System.out.println("BMW在跑");
        }
    }
    /**
     * 车接口
     */
    public interface Car{
        void draw();
    }
}

「特点」

首先，需要「创建」一个所有实现类都要实现的「接口类」，然后让所有实现类「实现这个接口类」，最后，「创建一个工厂类」，这个工厂类「提供一个创建方法」，根据传入的参数进行「创建实现类」。

可以看出，简单工厂的业务逻辑都集中在create方法中，这就「不利于扩展」，而且会使「业务逻辑」越来越「复杂」。

2.工厂方法

「概念」

工厂方法是一个类对应一个工厂，不再是通过一个工厂类来控制类的实例化。

「代码」

package factory;

/**
 * @author xxj
 * 工厂方法
 */
public class MethodFactory {
    public interface Car{
        void draw();
    }
    public interface fatory{
       Car create();
    }
    
    public class BMWCar implements Car{
        @Override
        public void draw() {
            System.out.println("BMW在跑");
        }
    }
    public class BENZCar implements Car{
        @Override
        public void draw() {
            System.out.println("BENZ在跑");
        }
    }
    public class BMWFactory implements fatory{
        @Override
        public Car create() {
            return new BMWCar();
        }
    }
    public class BENZFactory implements fatory{
        @Override
        public Car create() {
            return new BENZCar();
        }
    }
}

「特点」

「首先」，需要「创建两个接口」，一个是「目标类的接口」，一个是「工厂类的接口」。「然后」，「实现这两个接口」，「工厂类」需要有「一个」完成创建并「返回一个目标类实例方法」。 如果是只有一个目标类的话，可以不使用接口，直接创建目标类和接口类即可。

可以看出，这个是「一个工厂对应一个目标类」，「创建」的步骤「比较繁琐」，每添加一个目标类，就要手动的去创建一个工厂，但是它「降低了系统的复杂度」，不需要将判断创建那个工厂的逻辑全部放在一个工厂里，「提高了扩展性」，可以通过不断地实现目标类和工厂类的接口实现扩展。

和简单工厂的区别是：工厂方法是通过不同的方法来创建对象的，而简单工厂则是通过不同的参数在一个方法来创建对象

3.抽象工厂

「概念」

一般情况下，在需要「一个工厂创建特别多的目标类」时，就可以使用抽象工厂了。 和工厂方法的区别是：「工厂方法」是「一个工厂类对应一个目标类」，「抽象工厂」是「一个工厂类对应多个目标类」。

「代码」

package factory;

/**
 * @author xxj
 * 抽象工厂
 */
public class AbstractFactory {
    public interface Pants{
        int size=0;
        
    }
    public interface Clothes{
        int size=0;
    }
    public interface fatory{
        Pants createPants();
        Clothes createClothes();
    }
    public class XPants implements Pants{
    }
    public class XClothes implements Clothes{
    }
    public class XFactory implements fatory{
        @Override
        public Pants createPants() {
            return new XPants();
        }
        @Override
        public Clothes createClothes() {
            return new XClothes();
        }
    }
}

「特点」

首先，需要「创建一个工厂接口和多个目标类接口」，然后分别实现这些接口，「工厂类」则需要「有多个目标类的创建方法」。

这里的工厂接口严格一点的应该是「工厂抽象类」，又涉及到接口和抽象类的区别了，我也不是很懂，有空再学习一下。

抽象工厂的「扩展性」比工厂方法的「更高」了，但是「步骤」也是「更加繁琐」了，如果不是有特别多目标类，就不需要考虑抽象工厂了，这也比较适合规模比较大的架构来使用。

三、总结

目标类和工厂类可以组成一个x（目标类）y（工厂类）轴，这里的一个工厂类可以看成一个派系的类都需要在这个工厂类创建。 当x=1，y=1时，就不要考虑工厂模式了。 当「1<x，y=1」时，就优先考虑「简单工厂」。 当「x=1，1<y」时，就优先考虑「工厂方法」。 当「1<x，1<y」时，就优先考虑「抽象工厂」。