软件设计原则—依赖倒转原则

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

简单的说就是要求对抽象进行编程，不要对实现进行编程，这样就降低了客户与实现模块间的耦合。

下面看一个例子来理解依赖倒转原则：组装电脑

现要组装一台电脑，需要配件cpu，硬盘，内存条。只有这些配置都有了，计算机才能正常的运行。选择cpu有很多选择，如Intel，AMD等，硬盘可以选择希捷，西数等，内存条可以选择金士顿，海盗船等。

希捷硬盘类XiJieHardDisk）

package com.lmcode.principles.DependenceInversionPrinciple;

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

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

Intel处理器IntelCpu

package com.lmcode.principles.DependenceInversionPrinciple;

// Intel处理器
public class IntelCpu {
    public void run() {
        System.out.println("使用Intel处理器");
    }
}

金士顿内存条KingstonMemory

package com.lmcode.principles.DependenceInversionPrinciple;

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

电脑Computer

package com.lmcode.principles.DependenceInversionPrinciple;

public class Computer {
    private XiJieHardDisk hardDisk;
    private IntelCpu cpu;
    private KingstonMemory memory;

    public IntelCpu getCpu() {return cpu;}
    public void setCpu(IntelCpu cpu) {this.cpu = cpu;}
    public KingstonMemory getMemory() {return memory;}
    public void setMemory(KingstonMemory memory) {this.memory = memory;}
    public XiJieHardDisk getHardDisk() {return hardDisk;}
    public void setHardDisk(XiJieHardDisk hardDisk) {this.hardDisk = hardDisk;}

    public void run() {
        System.out.println("计算机工作");
        cpu.run();
        memory.save();
        String data = hardDisk.get();
        System.out.println("从硬盘中获取的数据为：" + data);
    }
}

测试类main用来组装电脑。

package com.lmcode.principles.DependenceInversionPrinciple;

public class main {
    public static void main(String[] args) {
        // 创建组件对象
        XiJieHardDisk xiJieHardDisk = new XiJieHardDisk();
        IntelCpu intelCpu = new IntelCpu();
        KingstonMemory kingstonMemory = new KingstonMemory();
        // 创建电脑对象
        Computer computer = new Computer();
        // 组装
        computer.setCpu(intelCpu);
        computer.setHardDisk(xiJieHardDisk);
        computer.setMemory(kingstonMemory);
        // 运行
        computer.run();
    }
}

上面代码可以看到已经组装了一台电脑，但是似乎组装的电脑的cpu只能是Intel的，内存条只能是金士顿的，硬盘只能是希捷的，这对用户肯定是不友好的，用户有了机箱肯定是想按照自己的喜好，选择自己喜欢的配件。

根据依赖倒转原则进行改进：

代码我们只需要修改Computer类，让Computer类依赖抽象（各个配件的接口），而不是依赖于各个组件具体的实现类。

面向对象的开发很好的解决了这个问题，一般情况下抽象的变化概率很小，让用户程序依赖于抽象，实现的细节也依赖于抽象。即使实现

细节不断变动，只要抽象不变，客户程序就不需要变化。这大大降低了客户程序与实现细节的耦合度。

cpu接口，硬盘接口，内存条接口

package com.lmcode.principles.DependenceInversionPrinciplePro;

//cpu接口
public interface Cpu {
//    运行cpu
    public void run();
}

package com.lmcode.principles.DependenceInversionPrinciplePro;

// 硬盘接口
public interface HardDisk {
//    存储数据
    public void save(String data);
//    获取数据
    public String get();
}

package com.lmcode.principles.DependenceInversionPrinciplePro;

//内存条接口
public interface Memory {
    public void save();
}

实现类

package com.lmcode.principles.DependenceInversionPrinciplePro;

// Intel处理器
public class IntelCpu implements Cpu{
    public void run() {
        System.out.println("使用Intel处理器");
    }
}

package com.lmcode.principles.DependenceInversionPrinciplePro;

// 金士顿内存条
public class KingstonMemory implements Memory{
    public void save() {
        System.out.println("使用金士顿作为内存条");
    }
}

package com.lmcode.principles.DependenceInversionPrinciplePro;

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

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

Computer

此时声明组件不能声明具体的实现类，而是父接口类型的抽象

package com.lmcode.principles.DependenceInversionPrinciplePro;

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("计算机工作");
        cpu.run();
        memory.save();
        String data = hardDisk.get();
        System.out.println("从硬盘中获取的数据为：" + data);

    }
}

main

package com.lmcode.principles.DependenceInversionPrinciplePro;

public class main {
    public static void main(String[] args) {
        // 创建组件对象
        HardDisk hardDisk = new XiJieHardDisk();
        Cpu cpu = new IntelCpu();
        Memory memory = new KingstonMemory();
        // 创建电脑对象
        Computer computer = new Computer();
        // 组装
        computer.setCpu(cpu);
        computer.setHardDisk(hardDisk);
        computer.setMemory(memory);
        // 运行
        computer.run();
    }
}

此时加入需要换cpu，只需要创建一个cpu的类，实现cpu接口，然后再main中创建新的cpu然后作为参数传递