1. 工厂（Factory）模式

工厂模式（Factory Pattern）提供了一种创建对象的最佳方式。我们不必关心对象的创建细节，只需要根据不同情况获取不同产品即可。难点：写好我们的工厂

2. 简单工厂(Simple Factory )

只定义一个具体工厂，由该工厂判断生产哪个产品。

缺点：违背开闭，扩展不易

05. 工厂（Factory）模式 - 图1

三个角色

Factory：工厂角色， WuLinFactory

/**
 * 简单工厂
 * 1.产品数量极少
 */
public class WuLinFactory {
    //简单工厂一切从简
    public AbstractCar newCar(String type) {
        if ("van".equals(type)) {
            return new VanCar();
        } else if ("mini".equals(type)) {
            return new MinCar();
        }
        return null;
    }
}

Product：抽象产品角色，Car

/**
 * 工厂产品
 */
public abstract class AbstractCar {
    String engine;
    public abstract void run();
}

ConcreteProduct：具体产品角色， VanCar、MiniCar

public class MinCar extends AbstractCar {
    public MinCar() {
        this.engine = "四缸发动机";
    }
    @Override
    public void run() {
        System.out.println(engine + "被生产");
    }
}

public class VanCar extends AbstractCar {
    public VanCar() {
        this.engine = "单杠柴油机";
    }
    @Override
    public void run() {
        System.out.println(engine + "被生产");
    }
}

测试方法:

    public static void main(String[] args) {
        WuLinFactory factory = new WuLinFactory();
        AbstractCar van = factory.newCar("van");
        AbstractCar mini = factory.newCar("mini");
        AbstractCar qwq = factory.newCar("qwq");
        van.run();
        System.out.println(van);
        mini.run();
        System.out.println(mini);
        System.out.println(qwq);
    }

3. 工厂方法(Factory Method)

将工厂抽象化，定义多个生产工厂，每个工厂只负责自己生产的产品。

缺点：系统复杂度增加，产品单一

05. 工厂（Factory）模式 - 图2

四个角色

Product：抽象产品

/**
 * 工厂产品
 *
 * 怎么把一个功能提升一个层次：定义抽象（抽象类、接口）
 * 抽象类，接口 就会有多实现 多实现自然有多功能
 */
public abstract class AbstractCar {
    String engine;
    public abstract void run();
}

ConcreteProduct：具体产品

三个具体产品

/**
 * 继承工厂抽象产品 为一个具体的产品
 */
public class VanCar extends AbstractCar {
    public VanCar() {
        this.engine = "单杠柴油机";
    }
    @Override
    public void run() {
        System.out.println(engine + "被生产");
    }
}

public class MiniCar extends AbstractCar {
    public MiniCar() {
        this.engine = "四缸发动机";
    }
    @Override
    public void run() {
        System.out.println(engine + "被生产");
    }
}

public class RacingCar extends AbstractCar {
    public RacingCar() {
        this.engine = "V8发动机";
    }
    @Override
    public void run() {
        System.out.println(engine + "被生产");
    }
}

Factory：抽象工厂

将生产方法抽象化

public abstract class AbstractCarFactory {
    public abstract AbstractCar newCar();
}

ConcreteFactory：具体工厂

有多少个产品就有多少个工厂

public class WulinMiniCarFactory extends AbstractCarFactory{
    @Override
    public AbstractCar newCar() {
    }
}

public class WulinRacingCarFactory extends AbstractCarFactory{
    @Override
    public AbstractCar newCar() {
        return new RacingCar();
    }
}

public class WulinVanCarFactory extends AbstractCarFactory{
    @Override
    public AbstractCar newCar() {
        return new VanCar();
    }
}

测试类

    public static void main(String[] args) {
        AbstractCarFactory carFactory = new WulinRacingCarFactory();
        AbstractCar abstractCar = carFactory.newCar();
        abstractCar.run();
        carFactory = new WulinMiniCarFactory();
        AbstractCar abstractCar1 = carFactory.newCar();
        abstractCar1.run();
        carFactory = new WulinVanCarFactory();
        AbstractCar abstractCar2 = carFactory.newCar();
        abstractCar2.run();
    }

4. 抽象工厂(Abstract Factory)

05. 工厂（Factory）模式 - 图3

05. 工厂（Factory）模式 - 图4

将工厂抽象化抽象方法为生产抽象类别，需要什么产品就创建什么工厂来生成。

抽象产品族：即抽象类别

public abstract class AbstractCar {
    String engine;
    public abstract void run();
}

public abstract class AbstractMask {
    Integer price;
    public abstract void protecteMe();
}

产品等级结构：生具体产品族的具体产品

public class MiniCar extends AbstractCar {
    public MiniCar() {
        this.engine = "四缸发动机";
    }
    @Override
    public void run() {
        System.out.println(engine + "被生产");
    }
}

public class VanCar extends AbstractCar {
    public VanCar() {
        this.engine = "单杠柴油机";
    }
    @Override
    public void run() {
        System.out.println(engine + "被生产");
    }
}

public class N95Mask extends AbstractMask {
    public N95Mask() {
        this.price = 2;
    }
    @Override
    public void protecteMe() {
        System.out.println("N95口罩被生产 价位为" + price);
    }
}

public class CommonMask extends AbstractMask {
    public CommonMask() {
        this.price = 1;
    }
    @Override
    public void protecteMe() {
        System.out.println("普通口罩被生成 价格为" + price);
    }
}

总厂规范：工厂全部产品族

可以再次细分工厂产品族，不生成的类别返回null，生成的类别为抽象（abstract）方法，让生成工厂实现单一类别的生成产品。

/**
 * 总厂规范
 */
public abstract class WulinFactory {
    abstract AbstractCar newCar();
    abstract AbstractMask newMask();
}

生成工厂：生成指定产品族的指定产品

public class WulinMiniCarFatory extends WulinFactory {
    @Override
    protected AbstractCar newCar() {
        return new MiniCar();
    }
    @Override
    AbstractMask newMask() {
        return null;
    }
}

public class WulinVanCarFatory extends WulinFactory {
    @Override
    protected AbstractCar newCar() {
        return new VanCar();
    }
    @Override
    AbstractMask newMask() {
        return null;
    }
}

public class WulinN95MaskFactory extends WulinFactory{
    @Override
    protected AbstractCar newCar() {
        return null;
    }
    @Override
    AbstractMask newMask() {
        return new N95Mask();
    }
}

public class WulinCommonMaskFactory extends WulinFactory{
    @Override
    protected AbstractCar newCar() {
        return null;
    }
    @Override
    AbstractMask newMask() {
        return new CommonMask();
    }
}

测试方法：

    public static void main(String[] args) {
        WulinFactory wulinFactory = new WulinCommonMaskFactory();
        AbstractMask commonMask = wulinFactory.newMask();
        commonMask.protecteMe(); //只生成普通口罩
        wulinFactory = new WulinN95MaskFactory();
        AbstractMask N95 = wulinFactory.newMask();
        N95.protecteMe(); //生成N95
        wulinFactory = new WulinMiniCarFatory();
        AbstractCar miniCar = wulinFactory.newCar();
        miniCar.run();
        wulinFactory = new WulinVanCarFatory();
        AbstractCar vanCar = wulinFactory.newCar();
        vanCar.run();
    }

5. 工厂模式的退化

当抽象工厂模式中每一个具体工厂类只创建一个产品对象，也就是只存在一个产品等级结构时，抽象工厂模式退化成工厂方法模式；当工厂方法模式中抽象工厂与具体工厂合并，提供一个统一的工厂来创建产品对象，并将创建对象的工厂方法设计为静态方法时，工厂方法模式退化成简单工厂模式。

6. 应用场景

NumberFormat、SimpleDateFormat
LoggerFactory：
SqlSessionFactory：MyBatis
BeanFactory：Spring的BeanFactory（就是为了造出bean）