设计模式之工厂模式

2、工厂模式

本文结合代码的方式，描述工厂模式。
工厂模式实现了创建者和调用者的分离

核心本质：

• 实例化对象，用工厂方法代替new操作
• 将选择实现类、创建对象统一管理和控制，将调用者和实现类解耦

2.1、工厂模式分类

• 简单工厂模式
  用来生产同一等级结构的任意产品（对于新增的产品需要修改已有的代码）
• 工厂方法模式
  用来生产同一等级结构的固有产品（支持增加任意产品）
• 抽象工厂模式
  用来生产不同产品族的全部产品，（不能增加新的产品，可以增加产品族）

2.2 面向对象设计的基本原则

• OCP（开闭原则）：一个软件实体应当对扩展开放，对修改关闭
• DIP（依赖倒置原则）：要针对接口编程，不要针对实现编程
• LOD（迪米特法则）：只与你直接的朋友通信，避免和陌生人通信

2.3、简单工厂模式

简单工厂模式也叫静态工厂模式，就是工厂类一般是使用静态方法，
通过接收的参数的不同来返回不同的对象实例
对于新增的产品无能为力，不修改代码的话，无法完成拓展

public interface Car {
    void run();
}
public class BaoMa implements Car{
    @Override
    public void run() {
        System.out.println("宝马在跑……");
    }
}
public class BenChi implements Car {
    @Override
    public void run() {
        System.out.println("奔驰在跑……");
    }
}
/**
 * 简单工厂类1
 * @author tqq
 * @date 2021-04-26-12:33
 */
public class CarFactory {
    public static Car createCar(String type){
        if ("宝马".equals(type)){
            return new BaoMa();
        }else if("奔驰".equals(type)){
            return new BenChi();
        }else {
            return null;
        }
    }
}
/**
 * 简单工厂类2
 * @author tqq
 * @date 2021-04-26-12:56
 */
public class CarFactory2 {
    public static Car createBaoMa(){
        return new BaoMa();
    }
    public static Car createBenChi(){
        return new BenChi();
    }
}
/**
 * 客户端调用
 * 简单工厂情况下
 * @author tqq
 * @date 2021-04-26-12:37
 */
public class Client2 {
    public static void main(String[] args) {
        Car c1 = CarFactory.createCar("宝马");
        Car c2 = CarFactory.createCar("奔驰");
        c1.run();
        c2.run();
        Car baoMa = CarFactory2.createBaoMa();
        Car benChi = CarFactory2.createBenChi();

    }
}

2.4、工厂方法模式

• 为了避免简单工厂模式的缺点，不完全满足OCP（开闭原则）
  工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个（对于一个项目
  或者一个独立模块而言）工厂类，而工厂方法模式有一组实现了相同接口的工厂类。

用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）

public interface Car {
    void run();
}
public interface CarFactory {
    public Car createCar();
}
public class BaoMa implements Car {
    @Override
    public void run() {
        System.out.println("宝马在跑……");
    }
}
public class BenChi implements Car {
    @Override
    public void run() {
        System.out.println("奔驰在跑……");
    }
}
public class BaoMaFactory implements CarFactory{
    @Override
    public Car createCar() {
        return new BaoMa();
    }
}
public class BenChiFactory implements CarFactory{
    @Override
    public Car createCar() {
        return new BenChi();
    }
}
/**
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
        Car baoma = new BaoMaFactory().createCar();
        baoma.run();

        Car benchi = new BenChiFactory().createCar();
        benchi.run();

    }
}

2.5、抽象工厂模式

代码以建造一辆汽车来进行展示

public interface Engine {
    void run();
}
class LuxuryEngine implements Engine{

    @Override
    public void run() {
        System.out.println("转的快");
    }
}
class LowEngine implements Engine{

    @Override
    public void run() {
        System.out.println("转的慢");
    }
}

public interface Seat {
    void message();
}
class LuxurySeat implements Seat{

    @Override
    public void message() {
        System.out.println("坐着舒服");
    }
}
class LowSeat implements Seat{

    @Override
    public void message() {
        System.out.println("坐着一般");
    }
}

public interface Tyre {
    void wheel();
}
class LuxuryTyre implements Tyre{

    @Override
    public void wheel() {
        System.out.println("耐磨");
    }
}
class LowTyre implements Tyre{

    @Override
    public void wheel() {
        System.out.println("耐磨性一般");
    }
}

public interface CarFactory {
    Engine createEngine();
    Seat createSeat();
    Tyre createTyre();
}
public class LowCarFactory implements CarFactory{
    @Override
    public Engine createEngine() {
        return new LowEngine();
    }

    @Override
    public Seat createSeat() {
        return new LowSeat();
    }

    @Override
    public Tyre createTyre() {
        return new LowTyre();
    }
}

public class LuxuryCarFactory implements CarFactory{
    @Override
    public Engine createEngine() {
        return new LuxuryEngine();
    }

    @Override
    public Seat createSeat() {
        return new LuxurySeat();
    }

    @Override
    public Tyre createTyre() {
        return new LuxuryTyre();
    }
}

/**
 * 客户端
 * 抽象工厂模式
 * @author tqq
 * @date 2021-04-26-14:36
 */
public class Client {
    public static void main(String[] args) {
        CarFactory lowCarFactory = new LowCarFactory();
        Engine engine = lowCarFactory.createEngine();
        engine.run();
    }
}

2.6、总结

• 简单工厂模式（静态工厂模式）
  虽然某种程度不符合设计原则，但实际用的最多
• 工厂方法模式
  不修改已有类的前提下，通过新增新的工厂类实现扩展
• 抽象工厂模式
  不可以增加产品，但是可以增加产品族

2.7、 应用场景

• spring中IOC容器创建bean对象
• XML解析时的DocumentBuilderFactory创建解析器对象
• 反射中Class对象的newInstance()