设计模式之工厂模式

🍭工厂模式

🍎定义

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

分类：

• 简单工厂（Simple Factory）【静态工厂】
• 工厂方法（Factory Method）【多态工厂】
• 抽象工厂（Abstract Factory）

🍟简单工厂

三个角色：

• Factory：工厂角色，WuLinFactory
• Product：抽象产品角色，Car
• ConcreateProduct：具体产品角色，VanCar、MiniCar

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

🍔代码实现

工厂的产品:

/**
 * 工厂的产品
 *
 */
public abstract class AbstractCar {
    public String engine;

    public abstract void run();
}

具体产品：

/**
 * 具体产品
 */
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 + " ===> 嘟嘟嘟...");
    }
}

简单工厂:

/**
 * 简单工厂
 * 1、产品数量有限
 */
public class WuLinSimpleFactory {

    public AbstractCar newCar(String type) {
        // 核心方法：一切从简
        if (type.equals("van")) {
            return new VanCar();
        } else if (type.equals("mini")) {
            return new MiniCar();
        }
        // 问题：更多的产品：违反开闭原则。应该直接扩展出一个类去造产品
        return null;
    }
}

测试：

public class MainTest {
    public static void main(String[] args) {
        WuLinSimpleFactory factory = new WuLinSimpleFactory();
        AbstractCar van = factory.newCar("van");
        AbstractCar mini = factory.newCar("mini");
        AbstractCar zzz = factory.newCar("zzz");
        van.run();
        mini.run();
    }
}

运行结果：

单缸柴油机 ===> 嗒嗒嗒...
四缸水平对置发动机 ===> 嘟嘟嘟...

🍟工厂方法

四个角色：

• Product：抽象产品
• ConcreateProduct：具体产品
• Factory：抽象工厂
• ConcreateFactory：具体工厂

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

🍔代码实现

就是把工厂再次抽象。

抽象车类：

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

    public abstract void run();
}

抽象车类具体实现：

/**
 * 具体产品
 */
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 + " ===> 嗖...");
    }
}

public class VanCar extends AbstractCar {

    public VanCar() {
        this.engine = "单缸柴油机";
    }

    @Override
    public void run() {
        System.out.println(engine + " ===> 嗒嗒嗒...");
    }
}

抽象工厂类：

/**
 * 抽象工厂的层级
 *
 */
public abstract class AbstractCarFactory {

    public abstract AbstractCar newCar();
}

抽象工厂类的具体实现：

/**
 * MiniCar 分厂
 */
public class WuLinMiniCarFactory extends AbstractCarFactory{
    @Override
    public AbstractCar newCar() {
        return new MiniCar();
    }
}

/**
 * RacingCar 分厂
 */
public class WuLinRacingCarFactory extends AbstractCarFactory {
    @Override
    public AbstractCar newCar() {
        return new RacingCar();
    }
}

/**
 * VanCar 分厂
 */
public class WuLinVanCarFactory extends AbstractCarFactory {
    @Override
    public AbstractCar newCar() {
        return new VanCar();
    }
}

测试：

public class MainTest {
    public static void main(String[] args) {
        AbstractCarFactory factory = new WuLinMiniCarFactory();
        AbstractCar car = factory.newCar();
        car.run();

        factory = new WuLinVanCarFactory();
        car = factory.newCar();
        car.run();

        factory = new WuLinRacingCarFactory();
        car = factory.newCar();
        car.run();
    }
}

运行结果：

四缸水平对置发动机 ===> 嘟嘟嘟...
单缸柴油机 ===> 嗒嗒嗒...
v8发动机 ===> 嗖...

🍟抽象工厂

人民需要什么，五菱就造什么。

🍔代码实现

汽车抽象类：

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

    public abstract void run();
}

汽车抽象类实现类：

/**
 * 具体产品
 */
public class VanCar extends AbstractCar {

    public VanCar() {
        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 + " ===> 嗖...");
    }
}

口罩抽象类：

/**
 * 抽象产品
 */
public abstract class AbstractMask {

    public Integer price;

    public abstract void protectedMe();
}

口罩抽象类实现类：

/**
 * 具体产品
 */
public class N95Mask extends AbstractMask {

    public N95Mask() {
        this.price = 2;
    }

    @Override
    public void protectedMe() {
        System.out.println("N95口罩......超级防护");
    }
}

/**
 * 具体产品
 */
public class CommonMask extends AbstractMask {

    public CommonMask() {
        this.price = 1;
    }

    @Override
    public void protectedMe() {
        System.out.println("普通口罩......普通防护");
    }
}

WuLing总厂抽象类：WULin集团 可以造什么：

/**
 * 总厂规范:WULin集团
 */
public abstract class WuLinFactory {
    abstract AbstractCar newCar();

    abstract AbstractMask newMask();
}

WuLing汽车抽象类：

/**
 * wuLin 汽车集团
 */
public abstract class WuLinCarFactory extends WuLinFactory{
    @Override
    abstract AbstractCar newCar() ;

    @Override
    AbstractMask newMask() {
        return null;
    }
}

WuLing口罩抽象类：

/**
 * wuLin 口罩集团
 */
public abstract class WuLinMaskFactory extends WuLinFactory {
    @Override
    AbstractCar newCar() {
        return null;
    }

    ;

    @Override
    abstract AbstractMask newMask();
}

WuLing汽车抽象类实现类：

/**
 * 分厂：负责造车
 */
public class WuLinVanCarFactory extends WuLinCarFactory {
    @Override
    AbstractCar newCar() {
        return new VanCar();
    }

}

/**
 * 分厂：负责造车
 */
public class WuLinRacingCarFactory extends WuLinCarFactory {
    @Override
    AbstractCar newCar() {
        return new RacingCar();
    }

}

WuLing口罩抽象类实现类：

/**
 * 分厂：负责口罩
 */
public class WuLinHangZhouMaskFactory extends WuLinMaskFactory {

    @Override
    AbstractMask newMask() {
        return new CommonMask();
    }
}

/**
 * 分厂：负责口罩
 */
public class WuLinWuHanMaskFactory extends WuLinMaskFactory {

    @Override
    AbstractMask newMask() {
        return new N95Mask();
    }
}

测试类：

/**
 * 一般我们要把一个东西抽象出来，可以使用抽象接口（只有方法），也可以使用抽象类（有些属性也需要用）
 */
public class MainTest {
    public static void main(String[] args) {
        WuLinFactory factory = new WuLinRacingCarFactory();
        factory.newCar().run();

        factory = new WuLinVanCarFactory();
        factory.newCar().run();

        factory = new WuLinHangZhouMaskFactory();
        factory.newMask().protectedMe();

        factory = new WuLinWuHanMaskFactory();
        factory.newMask().protectedMe();
    }
}

运行结果：

v8发动机 ===> 嗖...
单缸柴油机 ===> 嗒嗒嗒...
普通口罩......普通防护
N95口罩......超级防护

工厂模式的退化：

当抽象工厂模式中每一个具体工厂类只创建一个产品对象，也就是只存在一个产品等级结构时，抽象工厂模式就退化成工厂方法模式；

当工厂方法模式中抽象工厂与具体工厂合并，提供一个统一的工厂来创建产品对象，并将创建对象的工厂方法设计为静态方法时，工厂方法模式就退化成简单工厂模式。

🍕应用场景

• 什么场景用到？
  • NumberFormat、SimpleDateFormat
  • LoggerFactory
  • SqlSessionFactory
  • BeanFactory
  • …