【智能设计模式：AI时代的依赖倒转原则探索】

ImAileen

发布于 2024-12-24 08:12:04

13300

代码可运行

文章被收录于专栏：Python数据结构与算法Python数据结构与算法

运行总次数：0

代码可运行

依赖倒转原则（对开闭原则的具体实现）

高层模块不应该依赖于底层模块（A类是高层，B类是底层，X代表不依赖），两者都应依赖于其抽象；抽象不应该依赖细节，细节应该依赖抽象。

对抽象进行编程，不要对实现进行编程，这样就能降低客户与实现模块间的耦合。
下面我们将以组装电脑为例讲解一下依赖倒转原则。
- 现要组装一台电脑，需要配件CPU，硬盘，内存条。只有这些配置都有了，计算机才能正常运行。CPU有很多选择，如Intel，AMD等，硬盘可以选择希捷，西数等，内存条可以选择金士顿，海盗船等。

未使用依赖倒转原则实现的组装电脑

类图如下：

配件：

/**
 * @Description:希捷硬盘
 */

public class XiJieHardDisk {

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

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

/**
 * @Description:金士顿内存条类
 */

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

/**
 * @Description:因特尔的CPU
 */
public class IntelCpu {
    public void run() {
        System.out.println("使用Intel处理器");
    }
}

电脑

package principles.dependTrans.before;

public class Computer {

    //将三个配件组合在一起

    //声明成员变量
    private XiJieHardDisk hardDisk;
    private IntelCpu cpu;
    private KingstonMemory memory;


    //提供对应的get和set方法
    public XiJieHardDisk getHardDisk() {
        return hardDisk;
    }

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

    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 void run(){
        System.out.println("运行计算机。");
        //首先从硬盘获取数据
        String data = hardDisk.get();
        System.out.println("从硬盘上获取的数据是：" + data);
        //然后运行cpu
        cpu.run();
        //最后调用内存保存数据
        memory.save();
    }
}

测试类

public class ComputerTest {
    public static void main(String[] args) {
        //创建组件对象
        XiJieHardDisk hardDisk = new XiJieHardDisk();
        IntelCpu cpu = new IntelCpu();
        KingstonMemory memory = new KingstonMemory();

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

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

        //运行计算机
        c.run();
    }
}

小结：

上面代码可以看到已经组装好一台电脑了，但是组装的电脑的CPU只能是Intel的，内存条只能是金士顿的，硬盘只能是希捷的，这对用户来说是不友好的，用户的机箱肯定是想要按照自己的爱好，选择自己喜欢的配件。
- 下面我们根据依赖倒转原则对代码进行修改，代码只需要修改Computer类，让Computer类依赖抽象（各个配件的接口），而不是依赖于各个组件的具体实现类。

使用依赖倒转原则实现组装电脑

类图如下：

配件

package principles.dependTrans.after;

/**
 * @Description:希捷硬盘
 */
public class XiJieHardDisk implements HardDisk {

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

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

/**
 * @Description:金士顿内存条类
 */
public class KingstonMemory  implements Memory{
    public void save(){
        System.out.println("使用金士顿内存条");
    }
}

/**
 * @Description:因特尔的CPU
 */
public class IntelCpu implements Cpu{
    public void run() {
        System.out.println("使用Intel处理器");
    }
}

配件对应的实现接口

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

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

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

计算机

package principles.dependTrans.after;

public class Computer {
//    声明抽象接口
    private HardDisk hardDisk;
    private Cpu cpu;
    private Memory memory;

    //提供get 和 set 方法
    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
        cpu.run();
        //最后调用内存保存数据
        memory.save();
    }
}

测试类

public class ComputerTest {
    public static void main(String[] args) {
        //创建计算机的组件对象 - > new的不应该是接口，因该是子实现类对象
        HardDisk myhardDisk = new XiJieHardDisk();
        Cpu cpu = new IntelCpu();
        Memory memory = new KingstonMemory();

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

        //组装计算机
        c.setHardDisk(myhardDisk);
        c.setCpu(cpu);
        c.setMemory(memory);

        //运行计算机
        c.run();
    }
}

运行结果：

如果我要将它们换成自己想要的配件应该如何操作呢？
- 只需要创建对应的配件并实现对应的接口，让后通过computerTest这个类去创建对应的实例对象即可。
  - 如下所示：
  - 创建新配件

package principles.dependTrans.after;

public class AileenHardDisk implements HardDisk{
    public void save(String data){
        System.out.println("使用Aileen银盘存储数据"+ data);
    }

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

}

package principles.dependTrans.after;

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

package principles.dependTrans.after;

public class AileenMemory implements Memory{
    @Override
    public void save() {
        System.out.println("使用Aileen内存");
    }
}

测试类

package principles.dependTrans.after;


public class ComputerTest {
    public static void main(String[] args) {
        //创建计算机的组件对象 - > new的不应该是接口，因该是子实现类对象
        HardDisk aileenhardDisk = new AileenHardDisk();
        Cpu aileencpu = new AileenCpu();
        Memory aileenmemory = new AileenMemory();

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

        //组装计算机
        c.setHardDisk(aileenhardDisk);
        c.setCpu(aileencpu);
        c.setMemory(aileenmemory);

        //运行计算机
        c.run();
    }
}