JAVA设计模式七大原则—— 依赖倒转原则

JAVA设计模式七大原则—— 单一职责原则
JAVA设计模式七大原则—— 接口隔离原则
JAVA设计模式七大原则—— 依赖倒转原则
JAVA设计模式七大原则—— 里氏替换原则
JAVA设计模式七大原则—— 开闭原则
JAVA设计模式七大原则—— 迪米特法则
JAVA设计模式七大原则—— 合成复用原则

1：基本介绍

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

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

我们通过以下代码来说明
DependecyInversion.class

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接收消息的功能
class Person {
//以细节（类，Email类）为基础的架构
	public void receive(Email email ) {
		System.out.println(email.getInfo());
	}
}

如果我们获取的对象是 微信，短信等等，则新增类，同时Perons也要增加相应的接收方法，非常麻烦

解决方案：引入一个抽象的接口IReceiver, 表示接收者, 这样Person类与接口IReceiver发生依赖。因为Email, WeiXin 等等属于接收的范围，他们各自实现IReceiver 接口就可以了, 这样我们就符合依赖倒转原则

改进后
DependecyInversionImprove.class

public class DependecyInversion {
	public static void main(String[] args) {
		//客户端无需改变
		new Person().receive(new email());
		new Person().receive(new weiixng());
	}
}

//定义接口
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：以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。在java中，抽象 指的是接口或抽象类，细节就是具体的实现类
2：使用接口或抽象类的目的是制定好规范，而不涉及任何具体的操作，把展现细节的 任务交给他们的实现类去完成

依赖关系传递的三种方式和应用案例
1) 接口传递
DependencyPass .class

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

// 方式1： 通过接口传递实现依赖
// 开关的接口
 interface IOpenAndClose {
 public void open(ITV tv); //抽象方法,接收接口
 }

 interface ITV { //ITV接口
 public void play();
 }
 
 class ChangHong implements ITV {

	@Override
	public void play() {
		// TODO Auto-generated method stub
		System.out.println("长虹电视机，打开");
	}
	 
 }
// 实现接口
 class OpenAndClose implements IOpenAndClose{
 public void open(ITV tv){
 tv.play();
 }
 }

2) 构造方法传递
DependencyPass.class

public class DependencyPass {

	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() {
		// TODO Auto-generated method stub
		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方式传递
DependencyPass.class

public class DependencyPass {

	public static void main(String[] args) {
		ChangHong changHong = new ChangHong();
		//通过setter方法进行依赖传递
		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 OpenAndClose implements IOpenAndClose {
	private ITV tv;

	public void setTv(ITV tv) {
		this.tv = tv;
	}

	public void open() {
		this.tv.play();
	}
}

class ChangHong implements ITV {

	@Override
	public void play() {
		// TODO Auto-generated method stub
		System.out.println("长虹电视机，打开");
	}
	 

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

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