简单工厂模式，工厂方法模式----工厂模式

作用

实现了创建者和使用者的分离

核心本质

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

详细分类

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

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

• 抽象工厂模式：围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂

关于简单工厂的学习

Car接口：车的实现模板

public interface Car {
    void name();
}

Car1：实现Car接口的实现类

public class Car1 implements Car {
    @Override
    public void name() {
        System.out.println("car1");
    }
}

Car2：实现Car接口的实现类

public class Car2 implements Car {
    @Override
    public void name() {
        System.out.println("car2");
    }
}

CarFactory： 用于生产车的实例对象的工厂类

//不满足开闭原则
public class CarFactory {

    //方法一: 静态工厂方法，违背开闭原则
    public static Car getCar(String carName){
        if ("car1".equals(carName)){
            return new Car1();
        }else if ("car2".equals(carName)){
            return new Car2();
        }
        return null;
    }

    //方法二: 无需关系创建细节，直接new，然后返回
    public  static  Car1 getCar1(){
        return new Car1();
    }

    public  static  Car2 getCar2(){
        return new Car2();
    }
}

• 方法一为静态工厂方法，如果新增一个车类产品的话，需要对原来的类进行修改，违背了开闭原则，而且我们对于创建的细节进行处理。
• 方法二，如果新增一个车类产品的话，只是不需要改动原来的逻辑，但是这也改动了原来的类，不满足开闭原则。

test：测试类

/**
 * 工厂方法（静态工厂方法）:不符合开闭原则，但是实际上使用的最多
 */
public class test {
    public static void main(String[] args) {
        //普通new对象
//        Car1 car1 = new Car1();
//        Car2 car2 = new Car2();
//        car1.name();
//        car2.name();

        /**使用工厂去生成对象，不使用new，解耦
           缺点：当公司新出一个产品car3的时候，
                我们需要到carFactory里面在写一个相关的生成对象代码
                违背了开闭原则（对某个实体，只进行扩展，而不进行修改代码）
         **/
        Car car1 = CarFactory.getCar("car1");
        Car car2 = CarFactory.getCar("car2");
        car1.name();
        car2.name();
        //
    }
}

大白话：一个车工厂里面，什么车都在一个工厂生产。

关于工厂方法的学习

在上面的基础上，修改工厂方法

CarFactory 接口：车工厂生产的模板

public interface CarFactory {
    public Car getCar();
}

Car1Factory ：用于生产Car1的专门工厂

public class Car1Factory implements CarFactory {
    @Override
    public Car getCar() {
        return new Car1();
    }
}

Car2：用于生产Car2的工厂

public class Car2Factory implements CarFactory {
    @Override
    public Car getCar() {
        return new Car2();
    }
}

test：测试类

/**
 * 工厂方法模式；在不修改原来的类的基础上，进行新增的工厂类横向扩展
 */
public class test {
    public static void main(String[] args) {
        Car car1 = new Car1Factory().getCar();
        Car car2 = new Car2Factory().getCar();
        car1.name();
        car2.name();
    }
}

大白话：一个生产车的工厂里面，每辆车都会细分对于的车工厂，比如说宝马车工厂专门生产宝马，大奔的车工厂专门生产大奔。对不同的车区分出不同的工厂去生产。

这样的话，当新增一个产品的时候，就不需要修改原来的类了，就不会违背开闭原则，但是需要增加很多的类，这也是非常麻烦！！！

在我们实际开发中，使用简单工厂方法比工厂方法模式更多。所以说不一定说要满足oop七大原则才使用得多，都是根据需求和环境所更改的。