Java设计模式七大原则-依赖倒转(倒置)原则

冷不防 2023-10-11 19:59 29阅读 0赞

**目录**

依赖倒转原则

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

1. 接口传递

2.构造方法传递

3.setter方式传递

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

--------------------

## 依赖倒转原则 ##

**基本介绍**

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

**例子**

完成person接收消息

public class DependencyInvertion {
        public static void main(String[] args) {
            Person person = new Person();
            person.receive(new Email());
        }
    }
    
    class Email {
        public String getInfo() {
            return "电子邮件信息：hello";
        }
    }
    
    //完成person接收消息的功能
    class Person {
        public void receive(Email email) {
            System.out.println(email.getInfo());
        }
    }

**运行结果**

![262e20b200d745e6bd259984dcac3119.png][]

**分析**

问题：虽然比较容易想到且实现起来很简单，但是当我们接收消息的类不是email，而是message或者WeChat的时候，我们就需要新建类，且Person类需要新增方法，因为它的方法的参数已经定义为Email类

**解决思路**

引入一个抽象的接口IReceiver，表示接收者，这样Person类与接口IReceiver发生依赖因为Email，Weixin 等等属于接收的范围，他们各自实现IReceiver 接口就ok，这样我们就符合依赖倒转原则

**例子改进**

可以看到依赖抽象（接口或者抽象类）的稳定性相比于依赖细节（具体实现）更高，不需要增加方法，只需要增加类即可

public class DependencyInvertion {
        public static void main(String[] args) {
            //客户端无需改变
            Person person = new Person();
            person.receive(new Email());
            person.receive(new WeChat());
        }
    }
    
    interface IReceive {
        public String getInfo();
    }
    
    class Email implements IReceive{
        public String getInfo() {
            return "电子邮件信息：hello，Email";
        }
    }
    
    class WeChat implements IReceive {
    
        @Override
        public String getInfo() {
            return "微信信息：hello，Wechat";
        }
    }
    
    //完成person接收消息的功能
    class Person {
        public void receive(IReceive receive) {
            System.out.println(receive.getInfo());
        }
    }

**运行结果**

![2c2dec6a4cc64f92b076683dc4508670.png][]

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

###    1. 接口传递 ###

// 方式 1: 通过接口传递实现依赖
    // 开关的接口
    interface IOpenAndClose {
        public void open(ITV tv);//抽象方法，接收接口
    }
    interface ITV { //ITV接口
        public void play();
    }
    class ChangHong implements ITV {
    
        @Override
        public void play() {
            System.out.println("长虹电视机开启");
        }
    }
    //实现接口
    class OpenAndClose implements IOpenAndClose{
        public void open(ITV tv){
            tv.play();
        }
    }

###  ###

### 2.构造方法传递 ###

public class DependencyInvertion {
        public static void main(String[] args) {
            ChangHong changHong = new ChangHong();
            OpenAndClose openAndClose = new OpenAndClose(changHong);
            openAndClose.open();
        }
    }
    // 方式2: 通过构造方法依赖传递
    interface IOpenAndClose {
        public void open();
    }
    //抽象方法
    interface ITV {//ITV接口
    
        public void play();
    }
    
    class ChangHong implements ITV {
        @Override
        public void play() {
            System.out.println("长虹电视机开启");
        }
    }
    class OpenAndClose implements IOpenAndClose{
        public ITV tv; //成员
        public OpenAndClose(ITV tv) { //构造器
            this.tv = tv;
        }
    
        public void open(){
            this.tv.play();
        }
    }

###    3.setter方式传递 ###

public class DependencyInvertion {
        public static void main(String[] args) {
            ChangHong changHong = new ChangHong();
            OpenAndClose openAndClose = new OpenAndClose();
            openAndClose.setTv(changHong);
            openAndClose.open();
        }
    }
    // 方式3，通过setter方法传递
    interface IOpenAndClose {
        public void open(); // 抽象方法
        public void setTv(ITV tv);
    }
    
    interface ITV { // ITV接口
        public void play();
    }
    class ChangHong implements ITV {
        @Override
        public void play() {
            System.out.println("长虹电视机开启");
        }
    }
    class OpenAndClose implements IOpenAndClose {
        private ITV tv;
        public void setTv(ITV tv) {
            this.tv = tv;
        }
        public void open() {
            this.tv.play();
        }
    }

**运行结果**

![6ed4fdde31da4feda9c182579687282e.png][]

##  ##

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

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

[262e20b200d745e6bd259984dcac3119.png]: https://img-blog.csdnimg.cn/262e20b200d745e6bd259984dcac3119.png
[2c2dec6a4cc64f92b076683dc4508670.png]: https://img-blog.csdnimg.cn/2c2dec6a4cc64f92b076683dc4508670.png
[6ed4fdde31da4feda9c182579687282e.png]: https://img-blog.csdnimg.cn/6ed4fdde31da4feda9c182579687282e.png