依赖倒转（置）原则

系统管理员 2023-02-28 04:29 81阅读 0赞

#### 三、依赖倒转（置）原则 ####

#### 基本介绍 ####

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

#### 应用实例 ####

定义一个Person类用于接收邮件、微信等的消息

1.  不符合依赖倒转原则的写法

public class DependecyInversion {
        public static void main(String[] args) {
            Person person = new Person();
            person.receive(new Email());
        }
    }
    
    class Email{
        public String getInfo(){
            return "电子邮件信息：hello,world";
        }
    }
    
    // 完成Person接收消息的功能
    // 方式1 分析
    // 1. 简单，比较容易想到
    // 2. 如果我们获取的对象是 微信、短信等等，则新增类，同时Person也要增加相应的接收方法
    // 3. 解决思路：引入一个抽象的接口IReceiver，表示接收者，这样Person类与接口IReceiver发生依赖
    //    因为Email、WeiXin等属于接收的范围，她们各自实现IReceiver接口就可以，这样符合依赖倒转原则
    class Person {
        public void receive(Email email){
            System.out.println(email.getInfo());
        }
    }

1.  符合依赖倒转原则的写法

public class DependecyInversion {
        public static void main(String[] args) {
            //客户端无需改变
            Person person = new Person();
            person.receive(new Email());
            person.receive(new WeiXin());
        }
    }
    
    //定义接口
    interface IReceiver{
        public String getInfo();
    }
    
    class Email implements IReceiver{
        public String getInfo(){
            return "电子邮件信息：hello,world";
        }
    }
    
    class WeiXin implements IReceiver{
        public String getInfo(){
            return "微信信息：hello,ok";
        }
    }
    
    //方式2
    class Person {
        //这里我们是对接口进行依赖
        public void receive(IReceiver receiver){
            System.out.println(receiver.getInfo());
        }
    }

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

1）接口传递  
2）构造方法传递  
3）setter方式传递

**接口传递案例：**

public class DependecyInversion {
        public static void main(String[] args) {
            //方式1
            ChangHong changHong = new ChangHong();
            OpenAndClose openAndClose = new OpenAndClose();
            openAndClose.open(changHong);
        }
    }
    
    //方式1：通过接口传递，实现依赖
    //开关的接口
    interface IOpenAndClose{
        public void open(ITV tv); //抽象方法，接收接口
    }
    //ITV接口
    interface 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();
        }
    }

**构造方法传递案例：**

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

**setter方式传递案例：**

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