依赖倒置原则

定义：高层模块不应该依赖低层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象

以组装电脑为例：

存在的问题：现在的电脑只能使用给定的组件，如果要使用其他的，则违背了开闭原则

XiJie

public class XiJie {

    public void save(String data) {
        System.out.println("使用希捷硬盘存储数据：" + data);
    }

    public String get() {
        System.out.println("使用希捷硬盘读取数据");
        return "数据";
    }
}

Intel

public class Intel {

    public void run() {
        System.out.println("使用Intel cpu");
    }
}

Kingston

public class Kingston {

    public void save() {
        System.out.println("使用金士顿内存条");
    }
}

Computer

public class Computer {

    private XiJie hardDisk;
    private Intel cpu;
    private Kingston memory;

    public XiJie getHardDisk() {
        return hardDisk;
    }

    public void setHardDisk(XiJie hardDisk) {
        this.hardDisk = hardDisk;
    }

    public Intel getCpu() {
        return cpu;
    }

    public void setCpu(Intel cpu) {
        this.cpu = cpu;
    }

    public Kingston getMemory() {
        return memory;
    }

    public void setMemory(Kingston memory) {
        this.memory = memory;
    }

    public void run() {
        System.out.println("电脑运行了");
        String data = hardDisk.get();
        System.out.println("从硬盘上获取的数据是：" + data);
        cpu.run();
        memory.save();
    }
}

ComputerDemo

public class ComputerDemo {
    public static void main(String[] args) {
        //创建组件对象
        XiJie hardDisk = new XiJie();
        Intel cpu = new Intel();
        Kingston memory = new Kingston();

        Computer computer = new Computer();

        //组装计算机
        computer.setHardDisk(hardDisk);
        computer.setCpu(cpu);
        computer.setMemory(memory);

        //运行
        //存在的问题：现在的电脑只能使用给定的组件，如果要使用其他的，则违背了开闭原则
        computer.run();
    }
}

改进：

抽象出各个配件的接口，让Computer类依赖抽象，而不是依赖于各组件的具体实现类

HardDisk

public interface HardDisk {

    /**
     * 存储数据
     *
     * @param data 数据
     */
    void save(String data);

    /**
     * 读取数据
     *
     * @return
     */
    String get();
}

Cpu

public interface Cpu {

    /**
     * 运行
     */
    void run();
}

Memory

public interface Memory {

    /**
     * 保存
     */
    void save();
}

XiJie

public class XiJie implements HardDisk {

    @Override
    public void save(String data) {
        System.out.println("使用希捷硬盘存储数据：" + data);
    }

    @Override
    public String get() {
        System.out.println("使用希捷硬盘读取数据");
        return "数据";
    }
}

Intel

public class Intel implements Cpu {

    @Override
    public void run() {
        System.out.println("使用Intel cpu");
    }
}

AMD

public class Amd implements Cpu {

    @Override
    public void run() {
        System.out.println("使用AMD cpu");
    }
}

Kingston

public class Kingston implements Memory {

    @Override
    public void save() {
        System.out.println("使用金士顿内存条");
    }
}

Computer

public class Computer {

    private HardDisk hardDisk;
    private Cpu cpu;
    private Memory memory;

    public HardDisk getHardDisk() {
        return hardDisk;
    }

    public void setHardDisk(HardDisk hardDisk) {
        this.hardDisk = hardDisk;
    }

    public Cpu getCpu() {
        return cpu;
    }

    public void setCpu(Cpu cpu) {
        this.cpu = cpu;
    }

    public Memory getMemory() {
        return memory;
    }

    public void setMemory(Memory memory) {
        this.memory = memory;
    }

    public void run() {
        System.out.println("电脑运行了");
        String data = hardDisk.get();
        System.out.println("从硬盘上获取的数据是：" + data);
        cpu.run();
        memory.save();
    }
}

ComputerDemo

public class ComputerDemo {
    public static void main(String[] args) {
        //创建组件对象
        HardDisk xiJie = new XiJie();
        //Cpu intel = new Intel();
        Cpu intel = new Amd();
        Memory kingston = new Kingston();

        //创建计算机对象
        Computer computer = new Computer();

        //组装计算机
        computer.setHardDisk(xiJie);
        computer.setCpu(intel);
        computer.setMemory(kingston);

        //运行
        computer.run();
    }
}