依赖倒转_3

依赖倒转原则
基本介绍
1）高层模块不应该依赖底层模块，二者都应该依赖其抽象
2）抽象不应该依赖细节，细节应该依赖抽象
3）依赖倒转（倒置）核心思想是面向接口编程

应用实例
编程完成Person接受消息的功能

方式1分析

1.简单，比较容易想到
2.如果我们获取的对象是微信，短信等，则新增类，同时Person也要新增相应的接受方法
3.解决思路：引入一个抽象的接口IReceiver 表示接受者，这样Person类与接口IReceiver发生依赖，因为Emial,微信 等属于接受的范围， 他们各自实现IReceiver，接口就ok，就符合依赖倒转原则

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
 *     发生依赖，因为Emial,微信 等属于接受的范围， 他们各自实现IReceiver，接口就ok，
 *     就符合依赖倒转原则
 */
class Person{
    public  void receive(Email email){
        System.out.println(email.getInfo());
    }
}

优化方式2
此方式只需增加具体的实现，而不用修改客户端和Person的方法

public class DependecyInversion {

    public static void main(String[] args) {
        //客户段无需改变，只需要增加具体的实现类
        Person person = new Person();
        person.receive(new Email());
        person.receive(new Wexin());
    }
}

/**
 * 定义一个接口
 */
interface IReceiver{
    public String getInfo();
}

class Email implements IReceiver{

    public String getInfo(){
        return "电子邮件：hello,world";
    }
}
//增加一种新的接受方式
class Wexin implements IReceiver{

    @Override
    public String getInfo() {
        return "微信信息：hello ok";
    }
}


//完成Person接受消息的功能
class Person{
    //这里是对接口的依赖
    public  void receive(IReceiver receiver){
        System.out.println(receiver.getInfo());
    }
}

依赖关系传递的三种方式和应用案例
1.通过接口传递实现依赖

// 方式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.通过构造函数依赖传递

// 方式2: 通过构造方法依赖传递
 interface IOpenAndClose {
 	public void open(); //抽象方法
 }
 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();
 	}
 }

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("长虹电视机，打开");
	}
}

依赖倒置原则总结
1）底层模块尽量都要有抽象类或接口，活这两者都有，程序稳定性更好
2）变量的声明类型尽量是抽象类或接口，这样变量应用和实际对象，就存在一个缓冲层，利于程序扩展和优化
3）继承时遵循里氏替换原则