Java-设计模式-（二）软件设计原则---依赖倒转原则

 依赖倒转原则 基本介绍

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

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

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

    }
}


class Email{
    public String getInfo(){
        return "电子邮件信息：Hello World";
    }
}

//完成persion接收消息的功能
//方式1完成
/** 分析
 * 1.思路简单，容易想到
 * 2.如果获取的对象是微信，短信等，则需要新加类，同时Person类也要加相应的接收方法
 * 3.解决思路：引入一个人抽象的接口  IReceiver  用来表示接收者，这样Person类与接口 IReceiver 发生依赖
 *      因为Email，WeiXin 等属于接收的范围，
 *      各自实现 IRecevier 接口就行，这样我们就符合依赖倒转原则
 *
 * */
class Person{
    public void receive(Email email){
        System.out.println(email.getInfo());
    }
}

//方式2
public class DependcyInversion {
    public static void main(String[] args) {
        Person person = new Person();
        person.receive(new Email());
        person.receive(new WeiXin());

    }
}

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

class Email implements IReceiver{
    public String getInfo(){
        return "电子邮件信息：Hello World";
    }
}
class WeiXin implements IReceiver{

    @Override
    public String getInfo() {
        return "微信消息";
    }
}

class Person{
    //对接口依赖
    public void receive(IReceiver receiver){
        System.out.println(receiver.getInfo());
    }
}

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

1) 接口传递

public class DependencyPass {//依赖的传递方式

    public static void main(String[] args) {
        OpenAndClose openAndClose = new OpenAndClose();
        TV1 TV1 = new TV1();
        TV2 TV2 = new TV2();
        openAndClose.open(TV1);
        openAndClose.open(TV2);
    }
}

//方式一：通过接口传递实现依赖
interface ITV{
    public void play();
}
interface IOpenAndClose{
    public void open(ITV tv);//抽象方法，接收接口
}
class OpenAndClose implements IOpenAndClose{//开关
    @Override
    public void open(ITV tv) {
        tv.play();
    }
}
class TV1 implements ITV{
    @Override
    public void play() {
        System.out.println("遥控器打开了电视");
    }
}
class TV2 implements ITV{
    @Override
    public void play() {
        System.out.println("电视开关打开了电视");
    }
}

2) 构造方法传递

//构造方法传递
public class DependencyPass {
    public static void main(String[] args) {
        TV1 tv1 = new TV1();
        OpenAndClose openAndClose = new OpenAndClose(tv1);
        openAndClose.open();
    }
}

interface IOpenAndClose{
    public void open();//抽象方法
}
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 TV1 implements ITV {
    @Override
    public void play() {
        System.out.println("遥控器打开了电视");
    }
}
class TV2 implements ITV {
    @Override
    public void play() {
        System.out.println("电视开关打开了电视");
    }
}

3) setter方式传递

public class DependencyPass {
    public static void main(String[] args) {

        OpenAndClose openAndClose = new OpenAndClose();
        openAndClose.setTv(new TV1());
        openAndClose.open();

    }
}

interface IOpenAndClose{
    public void open();
    public void setTv(ITV tv);
}
interface ITV{
    public void play();
}
class OpenAndClose implements IOpenAndClose{
    private ITV tv;
    @Override
    public void open() {
        this.tv.play();
    }

    @Override
    public void setTv(ITV tv) {
        this.tv = tv;
    }
}
class TV1 implements ITV {
    @Override
    public void play() {
        System.out.println("遥控器打开了电视");
    }
}
class TV2 implements ITV {
    @Override
    public void play() {
        System.out.println("电视开关打开了电视");
    }
}

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

• 1) 低层模块尽量都要有抽象类或接口，或者两者都有，程序稳定性更好.

• 2) 变量的声明类型尽量是抽象类或接口, 这样我们的变量引用和实际对象间，就存在 一个缓冲层，利于程序扩展和优化

• 3) 继承时遵循里氏替换原则