工厂（Factory）模式

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

简单工厂模式（Simple Factory）

三个角色

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

缺点：违背开闭原则，每次新增产品都需要修改代码逻辑

代码实现

//抽象产品角色
public abstract class Car {
    abstract void run();
}

//产品具体的实现
@Data
public class MiniCar extends Car{
    private String name;
    private String age;
    @Override
    void run() {
        System.out.println("MiniCar");
    }
}

//产品的具体实现
@Data
public class VanCar extends Car{
    private String name;
    private String age;
    @Override
    void run() {
        System.out.println("VanCar");
    }
}

//工厂角色
public class WuLinFactory {
    public static Car newCar(String car) {
        if ("MiniCar".equals(car)) {
            return new MiniCar();
        }
        if ("VanCar".equals(car)) {
            return new VanCar();
        }
        return null;
    }
}

//测试类
public class CarTest {
    public static void main(String[] args) {
        Car miniCar = WuLinFactory.newCar("MiniCar");
        Car vanCar = WuLinFactory.newCar("VanCar");
        miniCar.run();
        vanCar.run();
    }
}

工厂(Factory)模式-工厂方法(Factory Method)

四个角色

• Product：抽象产品
• ConcreteProduct：具体产品
• Factory：抽象工厂
• ConcreteFactory：具体工厂

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

代码实现

//抽象产品角色
public abstract class Car {
    abstract void run();
}

//产品具体的实现
@Data
public class MiniCar extends Car{
    private String name;
    private String age;
    @Override
    void run() {
        System.out.println("MiniCar");
    }
}

//产品的具体实现
@Data
public class VanCar extends Car{
    private String name;
    private String age;
    @Override
    void run() {
        System.out.println("VanCar");
    }
}

//工厂具体实现
public class WulinMiniFactory extends WulinFactory{
    @Override
    public Car newCar() {
       return new MiniCar();
    }
}

//工厂具体实现
public class WulinVanFactory extends WulinFactory{
    @Override
    public Car newCar() {
        return new VanCar();
    }
}

//抽象工厂
public abstract class WulinFactory {
    public abstract Car newCar();
}

//测试
public class CarTest {
    public static void main(String[] args) {
        WulinFactory wulinVanFactory = new WulinVanFactory();
        WulinFactory wulinMiniFactory = new WulinMiniFactory();
        Car car = wulinVanFactory.newCar();
        Car car1 = wulinMiniFactory.newCar();
        car.run();
        car1.run();
    }
}

工厂(Factory)模式-抽象工厂(Abstract Factory)

与工厂方法模式的区别,顶级工厂抽象有所有创建工厂方法，子工厂按需实现
如何实现，人民需要什么，五菱就造什么

代码实现

//Car 顶层抽象
public abstract class Car {
    public abstract void run();
}

//N    顶层抽象
public abstract class N {
    public abstract void run();
}

@Data
public class MiniCar extends Car{
    private String name;
    private String age;
    @Override
    void run() {
        System.out.println("MiniCar");
    }
}

@Data
public class VanCar extends Car{
    private String name;
    private String age;
    @Override
    void run() {
        System.out.println("VanCar");
    }
}

public class N95 extends N{
    @Override
    public void run() {
        System.out.println("N95");
    }
}

public class N99 extends N{
    @Override
    public void run() {
        System.out.println("N99");
    }
}

/**
 * 定义总厂规范
 *
 */
public abstract class WulinFactory {
    public abstract Car newCar();
    public abstract N newN();
}

public class WulinMiniFactory extends WulinFactory{
    @Override
    public Car newCar() {
       return new MiniCar();
    }
    @Override
    public N newN() {
        return null;
    }
}

public class WulinVanFactory extends WulinFactory{
    @Override
    public Car newCar() {
        return new VanCar();
    }
    @Override
    public N newN() {
        return null;
    }
}

public class WulinN95Factory extends WulinFactory{
    @Override
    public Car newCar() {
       return null;
    }
    @Override
    public N newN() {
        return new N95();
    }
}

public class WulinN99Factory extends WulinFactory{
    @Override
    public Car newCar() {
       return null;
    }
    @Override
    public N newN() {
        return new N99();
    }
}

工厂模式的退化

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

什么场景用到？

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