【设计模式】想进工厂拧螺丝，就要先学会工厂模式，不然就只能去工地搬砖了

一、什么是工厂模式

1.概念

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

2.跟构建者模式的区别

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

3.工厂模式的使用场景

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

4.优点

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

5.缺点

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

二、工厂模式的分类

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时，就优先考虑抽象工厂。