Java设计模式——依赖倒转原则(实例)

1、基本介绍

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

2、应用实例

编程完成Person接收消息的功能

2.1未遵循依赖倒转原则

以下方式：简单，比较容易想到

如果获取的对象是WetChat,短信等，则需要新增类，同时也要增加Person相对应的接收方法

package com.weirdo.principle.inversion;
public class inversion {
    public static void main(String[] args) {
        Person person = new Person();
        person.receive(new Email());
    }
}
class Email{
    public String getInfo(){
        return "邮件信息：hello world";
    }
}
class Person{
    public void receive(Email email){
        System.out.println(email.getInfo());
    }
}

2.2遵循依赖倒转原则

引入一个抽象的接口IReceiver，表示接收者，让Person类与接口IReceiver发生依赖

因为Email，WetChat等属于接收的范围，他们各自实现IReceiver接口就行了，如此便符合依赖倒转原则

package com.weirdo.segregation;

public class Segregation1 {
    public static void main(String[] args) {
        A a = new A();
        a.depend1(new B());//A类通过接口去依赖B类
        a.depend2(new B());
        a.depend3(new B());
        C c = new C();
        c.depend1(new D());//C类通过接口去依赖D类
        c.depend4(new D());
        c.depend5(new D());
    }
}

interface Interface1 {
    void operation1();
}
interface Interface2{
    void operation2();
    void operation3();
}
interface Interface3{
    void operation4();
    void operation5();
}

class B implements Interface1,Interface2{
    @Override
    public void operation1() {
        System.out.println("B 实现了 operation1");
    }
    @Override
    public void operation2() {
        System.out.println("B 实现了 operation2");
    }
    @Override
    public void operation3() {
        System.out.println("B 实现了 operation3");
    }
}

class D implements Interface1,Interface3{
    @Override
    public void operation1() {
        System.out.println("D 实现了 operation1");
    }
    @Override
    public void operation4() {
        System.out.println("D 实现了 operation4");
    }
    @Override
    public void operation5() {
        System.out.println("D 实现了 operation5");
    }
}

/**
* 类A通过接口Interface1依赖（使用）B类,但是之会用到1，2，3方法
*/
class A{
    public void depend1(Interface1 i){
        i.operation1();
    }
    public void depend2(Interface2 i){
        i.operation2();
    }
    public void depend3(Interface2 i){
        i.operation3();
    }
}

/**
* 类C通过接口Interface1依赖（使用）D类,但是之会用到1，4，5方法
*/
class C{
    public void depend1(Interface1 i){
        i.operation1();
    }
    public void depend4(Interface3 i){
        i.operation4();
    }
    public void depend5(Interface3 i){
        i.operation5();
    }
}

3、注意事项和细节

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