狂神 - 工厂模式

作用：

• 实现了创建者和调用者的分离

• 详细分类：

  • 简单工厂模式

  • 工厂方法模式

  • 抽象工厂模式

OOP七大原则

• 开闭原则：一个软件的实体应当对扩展开放，对修改关闭

  • 只能添加，但是不能修改本身的东西
  • 对修改是关闭的

• 依赖倒转原则：要针对接口编程，不要针对实现编程

  • 面向接口编程，提取公共的接口，形成约束

• 迪米特法则：只与你直接的朋友通信，而避免和陌生人通信

  • 两个”人“交流，加一个中间类

核心本质：

• 实例化对象不使用new，用工厂方法代替
• 将选择实现类，创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。（主要作用）

三种模式：

• 简单工厂模式（静态工厂模式）
  • 用来生产同一等级结构中的任意产品（对于增加新的产品，需要扩展已有代码)
• 工厂方法模式
  • 用来生产同一等级结构中的固定产品(支持增加任意产品)
• 抽象工厂模式
  • 围绕一个超级工厂 创建其他工厂。该超级工厂又称为其他工厂的工厂。

简单工厂模式

流程图

思路

• 创建一个Car接口

• 创建两辆汽车的类（五菱、特斯拉），两辆汽车实现了Car接口

• 创建一个汽车工厂类CarFactory

  • 作用：拿车的，只需要传一个名字

• 创建一个消费者类

代码实现

Car接口

public interface Car {
    void name();
}

两个汽车类

五菱宏光

public class WuLing implements Car{
    @Override
    public void name() {
        System.out.println("五菱宏光！");
    }
}

特斯拉

public class Tesla implements Car{
    @Override
    public void name() {
        System.out.println("特斯拉！");
    }
}

汽车工厂类

public class CarFactory {
    public static Car getCar(String car){
        if (car.equals("五菱")){
            return new WuLing();
        } else if (car.equals("特斯拉")){
            return new Tesla();
        } else {
            return null;
        }
    }
}

消费者类

public class Consumer {
    public static void main(String[] args) {

        /*传统方式：
            接口，所有的实现类
        Car car = new WuLing();
        Car car2 = new Tesla();
        * */
        //使用工厂创建
        Car car1 = CarFactory.getCar("五菱");
        Car car2 = CarFactory.getCar("特斯拉");

        car1.name();
        car2.name();

    }
}

总结

简单工厂模式 又称 静态工厂模式

• 都使用的静态的方法

• 通过接受不同的参数，来返回不同的对象实例

缺点：

• 增加新的产品时，如果你不修改代码，做不到。
• 没有满足开闭原则

使用方面

• 在大多数用的情况下，直接用的简单工厂模式
  • 原因：要满足开闭原则，会付出很多代价（如：工厂方法模式）

工厂方法模式

流程图

思路

• 创建一个Car接口
• 创建两个汽车类（五菱、特斯拉），两辆汽车实现了Car接口
• 创建一个汽车工厂接口CarFactory
  • 多个工厂都实现了共同的接口
• 为每一辆车创建一个工厂类，每一辆车都实现了CarFactory接口
• 创建一个消费者类

代码实现

Car接口

public interface Car {
    void name();
}

两个汽车类

public class WuLing implements Car {
    @Override
    public void name() {
        System.out.println("五菱宏光！");
    }
}

public class Tesla implements Car {
    @Override
    public void name() {
        System.out.println("特斯拉！");
    }
}

汽车工厂接口

/*工厂方法模式
* 创建多个工厂
* 多个工厂都实现了共同的接口
* */
public interface CarFactory {
    Car getCar();
}

为每一辆车创建一个工厂类

//五菱工厂
public class WuLingFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new WuLing();
    }
}

//特斯拉工厂
public class TeslaFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new Tesla();
    }
}

添加一辆车

public class MoBai implements Car{
    @Override
    public void name() {
        System.out.println("摩拜单车");
    }
}

//摩拜单车工厂
public class MoBaiFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new MoBai();
    }
}

消费者类

//消费者
public class Consumer {
    public static void main(String[] args) {
        Car car = new WuLingFactory().getCar();
        Car car2 = new TeslaFactory().getCar();

        car.name();
        car2.name();


        Car car3 = new MoBaiFactory().getCar();
        car3.name();

    }
}

总结

简单工厂模式和工厂方法模式 对比：

结构复杂度：simple

代码复杂度：simple

编程复杂度：simple

管理复杂度：simple，都在一个类中管理多个

得出结论

根据设计原则：使用工厂方法模式！不会扰乱程序代码

根据实际业务：使用简单工厂模式！大多数软件都使用简单工厂模式

抽象工厂模式

假设有非常多的车，比如：Car里边有非常多零件，要设计很多接口

普通的工厂模式解决不了了，延伸出了抽象工厂模式

小结：

• 简单工厂模式(静态工厂模式)

  • 虽然某种程度上不符合设计原则，但实际使用最多!

• 工厂方法模式

  • 不修改已有类的前提下，通过增加新的工厂类实现扩展。

• 抽象工厂模式

  • 不可以增加产品，可以增加产品族!

• 应用场景：

  • JDK中Calendar的getInstance方法
  • JDBC中的Connection对象的获取
  • Spring中IOC容器创建管理bean对象
  • 反射中Class对象的newlnstance方法