IOC、DI、DIP

OCP: 开闭原则  对修改关闭  对扩展开放

1、面向对象主要做俩件事：实例化对象和调用方法（完成业务逻辑）

2、单纯interface可以统一方法的调用，但是不能统一对象的实例化

Hero接口类

public interface Hero {
    void q();
    void w();
    void e();
    void r();
}

Diana实现类

public class Diana implements Hero {
    @Override
    public void q() {
        System.out.println("Diana q");
    }

    @Override
    public void w() {
        System.out.println("Diana w");
    }

    @Override
    public void e() {
        System.out.println("Diana e");
    }

    @Override
    public void r() {
        System.out.println("Diana r");
    }
}

Trelia实现类

public class Irelia implements Hero {
    @Override
    public void q() {
        System.out.println("Irelia q");
    }

    @Override
    public void w() {
        System.out.println("Irelia w");
    }

    @Override
    public void e() {
        System.out.println("Irelia e");
    }

    @Override
    public void r() {
        System.out.println("Irelia r");
    }
}

Main调用类

public class Main {
    public static void main(String[] args) {
        String name = Main.getPlayerInput();
        Hero hero;
        switch (name) {
            case "Diana":
                hero = new Diana();
                break;
            case "Irelia":
                hero = new Irelia();
                break;
            default:
                throw new IllegalStateException("Unexpected value: " + name);
        }
        hero.r();
    }

    private static String getPlayerInput() {
        System.out.println("Enter a Hero name");
        Scanner scanner = new Scanner(System.in);
        return scanner.nextLine();
    }
}

Interface将方法进行统一，但是对象的实例化还是各自实例

3、只有一段代码中没有new的出现，才能保持代码的相对稳定，才能逐步实现OCP

要想保持代码的稳定，就不应该实例化对象

把实例化隔离到其他地方

实例化对象：以前是用的工厂模式(就是抽象化对象，然后每个对象单独进行实例化)和反射，现在最好的IOC和DI（这俩个不一样）

 

 JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制。（不懂）

 

工厂模式+反射不是IOC和DI

spring IOC也是用的工厂模式+反射思想，但是要更完善

IOC创建对象只创建一次，然后就放到缓存中

DIP： 依赖倒置  细节依赖抽象（不重要）

DI： 依赖注入   面向对象的项目就是对象之间产生相互的作用，对象与对象之间的作用必定会产生依赖，依赖是不可避免的，但是产生依赖的方式多种多样，

最普通的方法就是new一个对象，这种不好，因为new表示代码不稳定

最好的是对象由容器来创建，然后把对象注入到使用的对象里

最常用的是属性注入和构造注入