依赖倒置原则(Dependence Inversion Principle)
基本介绍
依赖倒置原则(Dependence Inversion Principle)是指:
- 高层模块不应该依赖底层模块,二者都应该依赖其抽象
- 抽象不应该依赖细节,细节应该依赖抽象
- 依赖倒置的中心思想是面向接口编程
- 依赖倒置原则是基于这样的设计理念:相对于细节的多变性,抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础的架构要稳定得多。在 Java 中,抽象指的是接口或抽象类,细节就是具体的实现类
- 使用接口或抽象类的目的是制定好规范,而不涉及任何具体的操作,把展现细节的任务交给他们的实现类去完成
应用案例
方案一
package com.lango.principle;
/**
* @author Lango
* @version 1.0
*/
public class DependencyInversion {
public static void main(String[] args) {
Person person = new Person();
person.receive(new Email());
}
}
// Email 类
class Email {
public String getInfo() {
return "电子邮件信息:hello,world";
}
}
// 完成 Person 接收消息的功能
// 方案 1
// 1. 简单,比较容易想到
// 2. 如果我们获取的对象是微信,短信等等,则新增类,同时 Person 也要增加相应的接收方法
// 3. 解决思路:引入一个抽象的接口 IReceiver,表示接收者,这样 Person 类与接口 IReceiver 发生依赖
// 因为 Email,WeiXin 等等属于接收的范围,他们各自实现 IReceiver 接口就 ok,这样我们就符合依赖倒置原则
class Person {
public void receive(Email email) {
System.out.println(email.getInfo());
}
}
- 简单,比较容易想到
- 如果我们获取的对象是微信,短信等等,则新增类,同时 Person 也要增加相应的接收方法
- 解决思路:引入一个抽象的接口 IReceiver,表示接收者,这样 Person 类与接口 IReceiver 发生依赖。因为 Email,WeiXin 等等属于接收的范围,他们各自实现 IReceiver 接口就 ok,这样我们就符合依赖倒置原则
方案二
package com.lango.principle.inversion.improve;
/**
* @author Lango
* @version 1.0
*/
public class DependencyInversion {
public static void main(String[] args) {
// 客户端无需改变
Person person = new Person();
// 邮件消息
person.receive(new Email());
// 微信消息
person.receive(new weChat());
}
}
// 定义一个接口
interface IReceiver{
public String getInfo();
}
// Email 类
class Email implements IReceiver{
@Override
public String getInfo() {
return "电子邮件信息:hello,Email";
}
}
// 增加 微信
class weChat implements IReceiver{
@Override
public String getInfo() {
return "微信信息:hello,weChat";
}
}
// 方式 2
class Person {
// 这里我们是对接口的依赖
public void receive(IReceiver iReceiver) {
System.out.println(iReceiver.getInfo());
}
}
- 引入一个抽象的接口 IReceiver,表示接收者
- Person 类与接口 IReceiver 发生依赖
- Email,WeiXin 等等属于接收的范围,他们各自实现 IReceiver 接口就 ok,这样我们就符合依赖倒置原则
依赖关系传递的三种方式
- 接口传递
- 构造方法传递
- setter 方式传递
package com.lango.principle.inversion.improve;
/**
* 依赖关系传递的三种方式
*
* @author Lango
* @version 1.0
*/
public class DependencyPass {
public static void main(String[] args) {
ChangHong changHong = new ChangHong();
// 通过接口传递实现依赖
// OpenAndClose openAndClose = new OpenAndClose();
// openAndClose.open(changHong);
// 通过构造器进行依赖传递
// OpenAndClose openAndClose = new OpenAndClose(changHong);
// openAndClose.open();
// 通过 setter 方法进行依赖传递
OpenAndClose openAndClose = new OpenAndClose();
openAndClose.setTv(changHong);
openAndClose.open();
}
}
方式 1:通过接口传递实现依赖
开关的接口
//interface IOpenAndClose {
// public void open(ITV tv); // 抽象方法,接收接口
//}
//
ITV 接口
//interface ITV {
// public void play();
//}
//
实现接口
//class OpenAndClose implements IOpenAndClose {
//
// @Override
// public void open(ITV tv) {
// tv.play();
// }
//}
//
//class ChangHong implements ITV{
//
// @Override
// public void play() {
// System.out.println("长虹电视机,打开");
// }
//}
方式 2:通过构造方法依赖传递
开关的接口
//interface IOpenAndClose {
// public void open();// 抽象方法
//}
//
ITV 接口
//interface ITV {
// public void play();
//}
//
实现接口
//class OpenAndClose implements IOpenAndClose {
//
// public ITV tv; // 属性(成员)
//
// public OpenAndClose(ITV tv) { // 构造器
// this.tv = tv;
// }
//
// @Override
// public void open() {
// this.tv.play();
// }
//}
//
//class ChangHong implements ITV{
//
// @Override
// public void play() {
// System.out.println("长虹电视机,打开");
// }
//}
// 方式 3:通过 setter 方法传毒
// 开关接口
interface IOpenAndClose {
public void setTv(ITV itv);
public void open(); // 抽象方法
}
// ITV 接口
interface ITV {
public void play();
}
// 实现方法
class OpenAndClose implements IOpenAndClose {
private ITV tv;
@Override
public void setTv(ITV tv) {
this.tv = tv;
}
@Override
public void open() {
this.tv.play();
}
}
class ChangHong implements ITV{
@Override
public void play() {
System.out.println("长虹电视机,打开");
}
}
依赖倒置原则的注意事项和细节
- 底层模块尽量都要有抽象类或者接口,或者两者都有,程序稳定性更好
- 变量的声明类型尽量是抽象类或接口,这样我们的变量引用和实际对象间,就存在一个缓冲层,利于程序扩展和优化
- 继承时遵循里氏替换原则