设计模式常用的七大原则之③【依赖倒转】原则

概念

依赖倒转原则(Dependence Inversion Principle)是指:

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

函数的参数应该是接口，而不是类；调用的时候就可以传接口的实现类了

案例

编程完成Person类发送消息的功能

代码1.0

package com.ABC.principle.inversion;

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

    }
}

class Email{
    public String getInfo(){
        return "电子邮件内容:hi";
    }
}


class Person{
    public void receive(Email email){  //直接传了类，如果email变成了微信QQ，就要增加新的类，Person新建方法
        System.out.println(email.getInfo());
    }

}

Person类的receive方法，直接传了Email类，如果email变成了微信QQ，就要增加新的类，Person要新建方法

解决思路

引入一个抽象接口IReceiver表示接收者，这样Person类与IReceiver接口发生依赖，引入微信qq时，各自实现IReceiver接口，不用修改Person类也可实现功能

package com.ABC.principle.inversion;

public class DependecyInversion {
    public static void main(String[] args) {
        new Person().receive(new Email());
        new Person().receive(new WeChat());
        new Person().receive(new QQ());
    }
}

interface IReceiver {
    public String getInfo();
}

class Email implements IReceiver {
    @Override
    public String getInfo() {
        return "电子邮件内容:hi";
    }
}

class WeChat implements IReceiver {
    @Override
    public String getInfo() {
        return "微信内容:hello";
    }
}
class QQ implements IReceiver {
    @Override
    public String getInfo() {
        return "QQ内容:hello~~~";
    }
}
class Person {
    public void receive(IReceiver iReceiver) {  //改成接口
        System.out.println(iReceiver.getInfo());
    }

}

依赖关系传递的三种方式和应用案例

接口传递

package com.ABC.principle.inversion;

interface TV {
    public void play();
}

interface IOpen {
    public void open(TV tv); // 接口传递
}

class ChangHong implements TV {
    @Override
    public void play() {
        System.out.println("长虹电视开机了...");
    }
}

class Open implements IOpen {

    @Override
    public void open(TV tv) {
        tv.play();
    }
}

public class Main {
    public static void main(String[] args) {
        ChangHong changHong = new ChangHong();
        new Open().open(changHong);
    }
}

构造方法传递

interface TV {
    public void play();
}

interface IOpen {
    public void open();
}

class ChangHong implements TV {
    @Override
    public void play() {
        System.out.println("长虹电视开机了...");
    }
}
class Open implements IOpen{
    private TV tv;
    public Open(TV tv){  //构造器
        this.tv = tv;
    }

    @Override
    public void open() {
        tv.play();
    }
}


public class Main {
    public static void main(String[] args) {
        new Open(new ChangHong()).open();
    }
}

set传递

interface TV {
    public void play();
}

interface IOpen {
    public void open();
}

class ChangHong implements TV {
    @Override
    public void play() {
        System.out.println("长虹电视开机了...");
    }
}
class Open implements IOpen{
    private TV tv;

    public void setTv(TV tv) {  // set方法
        this.tv = tv;
    }

    @Override
    public void open() {
        tv.play();
    }
}


public class Main {
    public static void main(String[] args) {
        Open open = new Open();
        open.setTv(new ChangHong());
        open.open();
    }
}

依赖倒转原则的注意事项和细节

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