JAVA设计原则：依赖倒转原则

依赖倒转原则

传统过程

传统的过程式设计倾向于使高层次的模块依赖于低层次的模块，抽象层依赖于具体的层次。例如上图中的，高级业务逻辑依赖中层模块，中层模块依赖于底层模块。

依赖倒转

实现层来依赖抽象层，抽象不应该依赖于细节，细节应该依赖于抽象，高层模块不依赖底层模块，两者都依赖抽象。

 

一、示例：组装电脑

1.1 MainBoard

//主板的抽象类
public abstract class MainBoard {
    public abstract void doSomething();
}

1.2 Memory

//内存的抽象类
public abstract class Memory {
    public abstract void doSomething();
}

1.3 HardDisk

//硬盘的抽象类
public abstract class HardDisk {
    public abstract void doSomething();
}

1.4 HuaSuoMainBoard

public class HuaSuoMainBoard extends MainBoard {
    public void doSomething() {
        System.out.println("华硕的主板");
    }
}

1.5 WeiXingMainBoard

public class WeiXingMainBoard extends MainBoard {
    public void doSomething() {
        System.out.println("微星的主板");
    }
}

1.6 JinShiDunMemory

public class JinShiDunMemory extends Memory {
    public void doSomething() {
        System.out.println("金士顿的内存");
    }
}

1.7 JinBangMemory

public class JinBangMemory extends Memory {
    public void doSomething() {
        System.out.println("金邦的内存");
    }
}

1.8 XiJieHardDisk

public class XiJieHardDisk extends HardDisk {
    public void doSomething() {
        System.out.println("希捷的硬盘");
    }
}

1.9 XiShuHardDisk

public class XiShuHardDisk extends HardDisk {
    public void doSomething() {
        System.out.println("西数的硬盘");
    }
}

 

第一种情况：

违反规则：高层模块依赖了底层模块，电脑是个高层模块，主板、内存、硬盘是底层模块，高层模块属性里面直接引用了底层，例如当主板故障需要更换时，不可以更换成其他品牌的了，只能是华硕

public class Computer {
    private HuaSuoMainBoard mainBoard;
    private JinShiDunMemory memory;
    private XiJieHardDisk disk;

    public String display() {
        return "Computer{" +
                "mainBoard=" + mainBoard +
                ", memory=" + memory +
                ", disk=" + disk +
                '}';
    }
	... getter and setter
}

第二种情况：

改造代码，让代码符合高层模块也依赖抽象模块

public class Computer {
    private MainBoard mainBoard;
    private Memory memory;
    private HardDisk hardDisk;

    public String display() {
        return "Computer{" +
                "mainBoard=" + mainBoard +
                ", memory=" + memory +
                ", disk=" + hardDisk +
                '}';
    }
    ... getter and setter
}

主函数：

public class MainClass {
    public static void main(String[] args){
        //这里符合里氏代换原则，父类一定适合子类
        Computer computer = new Computer();
        computer.setMainBoard( new HuaSuoMainBoard() );
        computer.setMemory( new JinShiDunMemory() );
        computer.setHardDisk( new XiJieHardDisk() );
        computer.display();
    }
}

 

二、实现依赖倒转原则

• 工厂方法模式：https://blog.csdn.net/weixin_43912883/article/details/97378705

• 模板方法模式：https://blog.csdn.net/weixin_43912883/article/details/101841035

• 迭代模式：https://blog.csdn.net/weixin_43912883/article/details/101803964