设计模式——（四）设计模式原则___依赖倒转原则

一、介绍

依赖倒转原则是指：
1）高层模块不应该依赖低层模块，二者都应该依赖其抽象。
2）抽象不应该依赖细节，细节应该依赖抽象。
3）依赖倒转原则的中心思想是面向接口编程。
4）依赖倒转原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础搭建的架构比细节为基础的架构要稳定的多。
也就是说，我们在进行编程的时候，我们要专注于抽象类和接口，以抽象类和接口为基础搭建软件的框架，而不是从具体的实现类处着手。
5）使用接口或抽象类的目的是制定“规范”，而不涉及任何具体的操作，并把展现细节的任务交给实现类来完成。

二、应用

假设我们需要编程，完成一个Person接收消息的功能。
那么我们有几种方案可以选择？

首先，我们容易想到这样的方案：

class Email{
		public String getInfo() {
			return "mail received from Kaguya";
		}
	}
	
class Person{
		public void receive(Email email) {
			System.out.println(email.getInfo());
		}
	}

客户端代码：

	public static void main(String[] args) {
		Person person = new Person();
		person.receive(new Email());
	}

这种设计是很容易的，我们在main中可以直接调用Person的receive方法，传入一个Email对象，然后调用Email的getInfo方法。
但是，当我们的需求发生这样的变化：我们希望接受其他种类的信息——很显然，一个现代社会的人类往往不会只接受单一来源的信息。如果我们需要给Person添加接收其他信息的方法，很明显修改起来十分复杂。需要添加新的方法，为了确保方法和类型一一对应还必须使用相应的方法，这无疑是冗余无必要的。
现在，我们引入一个抽象接口IReceiver表示接收者，
就有了如下的一种设计方案：

interface IReceiver{
		public String getInfo();
	}
	
	
	class Email implements IReceiver{
		public String getInfo() {
			return "mail received from Kaguya";
		}
	}
	
	class Person{
		public void receive(IReceiver receiver) {
			System.out.println(receiver.getInfo());
		}
	}

客户端代码无需改动。
这个方案较于原方案的好处在于，如果我需要接受其他的信息，修改起来十分简单：

	public static void main(String[] args) {
		Person shinogane = new Person();
		shinogane.receive(new Email());
		shinogane.receive(new Line());
		shinogane.receive(new QQ());
	}
	
}
	interface IReceiver{
		public String getInfo();
	}
	
	
	class Email implements IReceiver{
		public String getInfo() {
			return "mail received from Kaguya";
		}
	}
	
	class Line implements IReceiver{
		public String getInfo() {
			return "Line received from Kaguya";
		}
	}
	
	class QQ implements IReceiver{
		public String getInfo() {
			return "QQ massage received from Kaguya";
		}
	}
	
	class Person{
		public void receive(IReceiver receiver) {
			System.out.println(receiver.getInfo());
		}
	}

运行结果

可以看到我们很好地完成了需求。

再通过一个例子来加深理解：
假设我们需要实现一个打开电视的应用，我们来看并对比如下的三个方案：

方案1：通过接口传递实现依赖

	interface IOpenAndClose{
		public void open(ITV tv);
	}
	
	interface ITV{
		public void play();
	}
	
	class OpenAndClose implements IOpenAndClose{
		public void open(ITV tv) {
		tv.play();
		}
	}

在使用的时候，我们实例化ITV

	}
	
	class XiaomiTV implements ITV{
		@Override
		public void play() {
			System.out.println("XiaomiTV is opened.");
		}
	}

客户端代码如下

public static void main(String[] args) {
		XiaomiTV XMTV = new XiaomiTV();
		OpenAndClose OAC = new OpenAndClose();
		OAC.open(XMTV);
	}	

方案二：通过构造器实现依赖传递

	interface IOpenAndClose{
		public void open();
	}
	
	interface ITV{
		public void play();
	}
	
	class OpenAndClose implements IOpenAndClose{
		public ITV tv;
		public OpenAndClose(ITV tv) {
			this.tv = tv;
		}
		public void open() {
			this.tv.play();
		}
	}
	

客户端代码如下

	public static void main(String[] args) {
		XiaomiTV XMTV = new XiaomiTV();
		OpenAndClose OAC = new OpenAndClose(XMTV);
		OAC.open();	
	}	

方案三：通过setter方法传递

	interface IOpenAndClose{
		public void open();
		
		public void setTv(ITV tv);
	}
	
	interface 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();
		}
		
	}

客户端代码如下

	XiaomiTV XMTV = new XiaomiTV();
	OpenAndClose OAC = new OpenAndClose();
	OAC.setTv(XMTV);
	OAC.open();

总结：
在开发的时候，我们经常会采用
1）接口传递
2）构造方法传递
3）setter方式传递
这三种方式来进行设计，以遵循依赖倒转原则。