工厂模式之静态工厂模式和工厂方法模式

1.简介

工厂模式作用：实现了创建者和调用者的分离
详细分类:

1. 静态工厂模式：用来生产同一等级结构中的任意产品（对于增加新的产品，需要覆盖已有的代码），又叫简单工厂模式

2. 工厂方法模式：用来生产统一等级结构中的固定产品（支持增加的任意产品）

3. 抽象工厂模式：围绕一个禅机共产创建其他工厂，该超级工厂又称为其他工厂的工厂（工厂的工厂）。

核心本质：
实例化对象不使用new，用工厂方法代替。
将选择实现类，创建对象统一管理和控制，从而将调用者跟我们的实现类解耦。
应用场景：
JDK中Calendar的getInstance方法
JDBC中的Connection对象的获取
Spring中IOC容器创建管理bean对象
反射中Class对象的newInstance方法

2.静态工厂模式

/**
 * 静态工厂模式（简单工厂模式）
 * 大多数情况下都使用这种模式
 * 缺点：不满足开闭原则，每次增加一种类型，都需要在这里修改代码
 * 但是开闭原则需要付出比较大的代价
 */
public class CarFactory {
    //方法一
    public static Car getCar(String car){
        if(car.equals("小黄单车")){
            return new XiaoHuang();
        }else if (car.equals("小红单车")){
            return new XiaoHong();
        }else if (car.equals("小蓝单车")){
            return new XiaoLan();
        }else{
            return null;
        }
    }

    //方法二（将每一种车都自己创建一个方法）
    public static Car getXiaoHong(){
        return new XiaoHong();
    }
    public static Car getXiaoLan(){
        return new XiaoLan();
    }
    public static Car getXiaoHuang(){
        return new XiaoHuang();
    }
}

//顾客
public class Consumer  {
    public static void main(String[] args) {
    /*传统方法
        XiaoHong xh = new XiaoHong();
        xh.car();
        XiaoHuang xiaoHuang = new XiaoHuang();
        xiaoHuang.car();
    */
        
    /*  方法一
        Car c1 = CarFactory.getCar("小蓝单车");
        Car c2 = CarFactory.getCar("小红单车");
    */
  
    //方法二：
        Car c1 = CarFactory.getXiaoHong();
        Car c2 = CarFactory.getXiaoLan();

        c1.car();
        c2.car();

    }
}
//car接口
public interface Car {
    void car();
}
//每一种车型
public class XiaoLan implements Car {
    @Override
    public void car() {
        System.out.println("小蓝单车");
    }
}

3.工厂方法模式

/**
 * 工厂方法模式：需要哪个车就去哪个车的工厂去取
 * 优点：不修改已有代码的前提下，通过增加新的工厂类实现扩展
 * 缺点：类太多，比起简单工厂模式来说，虽然实现了开闭原则，但是很麻烦。
 */
//工厂接口
public interface CarFactory{
    Car getCar();
}
//每个车的工厂-小蓝车厂
public XiaoLanFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new XiaoLan();
    }
}
//每个车的工厂-小红车厂
public class HongFactory implements CarFactory {

    @Override
    public Car getCar() {
        return new XiaoHong();
    }
}
//车接口
public interface Car {
    void car();
}
//车产品-小蓝车
public class XiaoLan implements Car {
    @Override
    public void car() {
        System.out.println("小蓝单车");
    }
}
//车产品-小红车
public class XiaoHong implements Car {
    @Override public void car() {
        System.out.println("小红单车");
    }
}
//顾客
public class Consumer  {
    public static void main(String[] args) {

        //需要什么车，就去哪个车的工厂
        Car c1 = new LanFactory().getCar();
        Car c2 = new HongFactory().getCar();

        c1.car();
        c2.car();

    }
}

4.小结：

通过以下方面对比：
结构复杂度：选 静态工厂模式
代码复杂度：选 静态工厂模式
编程复杂度：选 静态工厂模式
管理上的复杂度：选 静态工厂模式

根据设计原则：选 工厂方法模式
根据实际业务：选 静态工厂模式

综上：
静态工厂模式:虽然某种程度上不符合设计原则，但实际使用最多。
工厂方法模式：不修改已有类的前提下，通过增加新的工厂类实现扩展。

( 简单提一下抽象工厂模式。)
抽象工厂模式：不可以增加产品，可以增加产品族。