1.1 基本介绍


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

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

1.2 应用实例

请编程完成 Person接收消息 的功能。

1）实现方案 1 + 分析说明

  1. package com.atguigu.principle.inversion;
  3. public class DependecyInversion {
  5.     public static void main(String[] args) {
  6.         Person person = new Person();
  7.         person.receive(new Email());
  8.     }
  10. }
  13. class Email {
  14.     public String getInfo() {
  15.         return "电子邮件信息: hello,world";
  16.     }
  17. }
  19. //完成Person接收消息的功能
  20. //方式1分析
  21. //1. 简单，比较容易想到
  22. //2. 如果我们获取的对象是 微信，短信等等，则新增类，同时Perons也要增加相应的接收方法
  23. //3. 解决思路：引入一个抽象的接口IReceiver, 表示接收者, 这样Person类与接口IReceiver发生依赖
  24. //   因为Email, WeiXin 等等属于接收的范围，他们各自实现IReceiver 接口就ok, 这样我们就符号依赖倒转原则
  25. class Person {
  26.     public void receive(Email email ) {
  27.         System.out.println(email.getInfo());
  28.     }
  29. }

2）实现方案 2(依赖倒转) + 分析说明

  1. package com.atguigu.principle.inversion.improve;
  3. public class DependecyInversion {
  5.     public static void main(String[] args) {
  6.         //客户端无需改变
  7.         Person person = new Person();
  8.         person.receive(new Email());
  10.         person.receive(new WeiXin());
  11.     }
  13. }
  15. //定义接口
  16. interface IReceiver {
  17.     public String getInfo();
  18. }
  20. class Email implements IReceiver {
  21.     public String getInfo() {
  22.         return "电子邮件信息: hello,world";
  23.     }
  24. }
  26. //增加微信
  27. class WeiXin implements IReceiver {
  28.     public String getInfo() {
  29.         return "微信信息: hello,ok";
  30.     }
  31. }
  33. //方式2
  34. class Person {
  35.     //这里我们是对接口的依赖
  36.     public void receive(IReceiver receiver ) {
  37.         System.out.println(receiver.getInfo());
  38.     }
  39. }

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

1）接口传递

2）构造方法传递应用案例代码

3）setter方式传递

4）代码演示

  1. package com.atguigu.principle.inversion.improve;
  3. public class DependencyPass {
  5.     public static void main(String[] args) {
  6.         // TODO Auto-generated method stub
  7.         ChangHong changHong = new ChangHong();
  8. //        OpenAndClose openAndClose = new OpenAndClose();
  9. //        openAndClose.open(changHong);
  11.         //通过构造器进行依赖传递
  12. //        OpenAndClose openAndClose = new OpenAndClose(changHong);
  13. //        openAndClose.open();
  14.         //通过setter方法进行依赖传递
  15.         OpenAndClose openAndClose = new OpenAndClose();
  16.         openAndClose.setTv(changHong);
  17.         openAndClose.open();
  19.     }
  21. }
  23. // 方式1： 通过接口传递实现依赖
  24. // 开关的接口
  25. // interface IOpenAndClose {
  26. // public void open(ITV tv); //抽象方法,接收接口
  27. // }
  28. //
  29. // interface ITV { //ITV接口
  30. // public void play();
  31. // }
  32. // 
  33. // class ChangHong implements ITV {
  34. //
  35. //    @Override
  36. //    public void play() {
  37. //        // TODO Auto-generated method stub
  38. //        System.out.println("长虹电视机，打开");
  39. //    }
  40. //     
  41. // }
  42. //// 实现接口
  43. // class OpenAndClose implements IOpenAndClose{
  44. // public void open(ITV tv){
  45. // tv.play();
  46. // }
  47. // }
  49. // 方式2: 通过构造方法依赖传递
  50. // interface IOpenAndClose {
  51. // public void open(); //抽象方法
  52. // }
  53. // interface ITV { //ITV接口
  54. // public void play();
  55. // }
  56. // class OpenAndClose implements IOpenAndClose{
  57. // public ITV tv; //成员
  58. // public OpenAndClose(ITV tv){ //构造器
  59. // this.tv = tv;
  60. // }
  61. // public void open(){
  62. // this.tv.play();
  63. // }
  64. // }
  67. // 方式3 , 通过setter方法传递
  68. interface IOpenAndClose {
  69.     public void open(); // 抽象方法
  71.     public void setTv(ITV tv);
  72. }
  74. interface ITV { // ITV接口
  75.     public void play();
  76. }
  78. class OpenAndClose implements IOpenAndClose {
  79.     private ITV tv;
  81.     public void setTv(ITV tv) {
  82.         this.tv = tv;
  83.     }
  85.     public void open() {
  86.         this.tv.play();
  87.     }
  88. }
  90. class ChangHong implements ITV {
  92.     @Override
  93.     public void play() {
  94.         // TODO Auto-generated method stub
  95.         System.out.println("长虹电视机，打开");
  96.     }
  98. }

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


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