GoF23-依赖倒置原则

依赖倒置原则

依赖倒置原则概念

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

应用场景

完成模拟Person接收消息的功能
（例如接收邮件、qq、微信消息）

代码实现(传统方法)

package com.tan.principle.dependence_inversion;

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

class Email {
    public String getInfo() {
        return "请查收邮件：Hello World";
    }
}

/*
完成Person接收消息的功能
问题分析：
1.方法简单
2.receive方法的形参是一个Email类，那如果接收到的qq消息，微信消息等等，则不仅需要新增一个类，且Person类也要增加相应的接受方法

解决思路：
引入一个抽象的接口IReceiver,表示接收者,这样Person类与接口IReceiver发生依赖
此时Email、WeChat等等属于接受的范围，它们各自实现IReceiver接口就可以，这样就使代码符合依赖倒置原则
 */
class Person {
    public void receive(Email email){
        System.out.println(email.getInfo());
    }

}

代码优化(依赖倒置原则)

package com.tan.principle.dependence_inversion.improve;

/*
跟接口发生依赖

依赖关系传递的三种方式：
1.接口传递
2.构造方法传递
3.setter方法传递
 */
public class DependenceInversionImprove {
    public static void main(String[] args) {
        Person person = new Person();
        person.receive(new Email());

        person.receive(new WeChat());
    }
}

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

class Email implements IReceiver {
    public String getInfo() {
        return "请查收邮件：Hello World";
    }
}

class WeChat implements IReceiver {

    public String getInfo() {
        return "请查收微信信息：Hello World";
    }
}


class Person {
    public void receive(IReceiver receiver){
        System.out.println(receiver.getInfo());
    }

}

依赖关系传递的三种方式

依赖关系传递的三种方式：
1.接口传递
2.构造方法传递
3.setter方法传递

package com.tan.principle.dependence_inversion.improve;

/*
依赖关系传递的三种方式：
1.接口传递
2.构造方法传递
3.setter方法传递
 */
public class DependencyPass {
    public static void main(String[] args) {
//        ChangHong changHong = new ChangHong();
//        OpenAndClose openAndClose = new OpenAndClose();
//        openAndClose.open(changHong);

//        ChangHong changHong = new ChangHong();
//        OpenAndClose openAndClose = new OpenAndClose(changHong);
//        openAndClose.open();

        ChangHong changHong = new ChangHong();
        OpenAndClose openAndClose = new OpenAndClose();
        openAndClose.setTv(changHong);
        openAndClose.open();

    }
}

class ChangHong implements ITV {
    @Override
    public void play() {
        System.out.println("打开了长虹电视机");
    }
}

/*
方式一：通过接口实现依赖传递
 */
 
//interface IOpenAndClose {
//    public void open (ITV tv);//抽象方法，接受接口
//}
//
ITV接口
//interface ITV {
//public void play();
//}
//
实现接口
//class OpenAndClose implements IOpenAndClose {
//    public void open(ITV tv){
//        tv.play();
//    }
//}

/*
方式二：通过构造方法实现依赖传递
 */
//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();
//    }
//}

/*
方法三：通过setter方法实现依赖传递
 */
interface IOpenAndClose {
    //抽象方法
    public void open();

    public void setTv(ITV tv);
}

//ITV接口
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();
    }
}

依赖倒置原则的注意事项

依赖倒置原则的注意事项：
1.低层模块尽量都要有抽象类或接口，或者两者都有，程序稳定性更好

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

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