六大设计原则--依赖倒置原则（dip）

1.概述

1. 高层模块不应该依赖低层模块，二者都应该依赖其抽象
2. 抽象不应该依赖细节，细节应该依赖抽象
3. 依赖倒转(倒置)的中心思想是面向接口编程
4. 依赖倒转原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。在java中，抽象指的是接口或抽象类，细节就是具体的实现类。
5. 使用接口或抽象类的目的是制定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类去完成。

2.案例

2.1.描述

接受信息，我们在接受信息时，可能会接受：邮件，电话，视频等

2.2.代码

class Email{
    public void info(){
        System.out.println("email");
    }
}
class Phone{
    public void info(){
        System.out.println("phone");
    }
}
class Video{
    public void info(){
        System.out.println("video");
    }
}
class  Test{
    public static void main(String[] args) {
        ReceiveHandler t=new ReceiveHandler();
        t.receive1(new Email());
        t.receive2(new Phone());
        t.receive3(new Video());
    }
}

public class ReceiveHandler {
    public void receive1(Email e){
        e.info();
    }
    public void receive2(Phone p){
        p.info();
    }
    public void receive3(Video v){
        v.info();
    }


}

2.3.分析

使用传统的方式，我们需要针对不同的接受类型创建对应的方法，对于扩展功能时，我们都需要对于的实现，那么功能较多时，实现就会越多，后面就越难维护。

2.4改善

我们创建一个接受信息的的接口，定义好规则，不同的信息类型去创建不同的实现，在实际调用时我们只需要写这个接口对于的处理，实际根据传入的不同，接受不同的信息类型。

interface ReceiveType{
    void info();
}
class Email implements ReceiveType {
    public void info(){
        System.out.println("email");
    }
}
class Phone implements ReceiveType{
    public void info(){
        System.out.println("phone");
    }
}
class Video implements ReceiveType{
    public void info(){
        System.out.println("video");
    }
}

/*
信息处理类
*/
public class ReceiveHandler2 {
    public void receive(ReceiveType receiveType){
        receiveType.info();
    }
}

测试

class Test{
    public static void main(String[] args) {
        ReceiveHandler2 receiveHandler2=new ReceiveHandler2();
        receiveHandler2.receive(new Email());
        receiveHandler2.receive(new Phone());
        receiveHandler2.receive(new Video());
    }
}

3.注意事项和细节

1. 低层模块尽量都要有抽象类或接口，或者两者都有，程序稳定性更好.
2. 变量的声明类型尽量是抽象类或接口, 这样我们的变量引用和实际对象间，就存在 一个缓冲层，利于程序扩展和优化
3. 继承时遵循里氏替换原则