依赖倒转原则

逃离我推掉我的手 2021-07-25 01:43 347阅读 0赞

# 一 点睛 #

高层模块不应该依赖低层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象。简单的说就是要求对抽象进行编程，不要对实现进行编程，这样就降低了客户与实现模块间的耦合。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5ncWl1bWluZw_size_16_color_FFFFFF_t_70]

# 二 需求 #

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

# 三 反例 #

## 1 类图 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5ncWl1bWluZw_size_16_color_FFFFFF_t_70 1]

## 2 代码 ##

**希捷硬盘类（XiJieHardDisk）:**

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

**Intel处理器（IntelCpu）：**

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

**金士顿内存条（KingstonMemory）：**

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

**电脑（Computer）：**

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);
        }
    }

**测试类（TestComputer）：**

测试类用来组装电脑。

public class TestComputer { 
        public static void main(String[] args) { 
            Computer computer = new Computer();
            computer.setHardDisk(new XiJieHardDisk());
            computer.setCpu(new IntelCpu());
            computer.setMemory(new KingstonMemory());
    
            computer.run();
        }
    }

## 3 测试结果 ##

运行计算机
    使用希捷希捷硬盘取数据
    从硬盘上获取的数据是：数据
    使用Intel处理器
    使用金士顿内存条

## 4 分析 ##

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

# 四 正例 #

## 1 说明 ##

根据依赖倒转原则进行改进。代码只需要修改Computer类，让Computer类依赖抽象（各个配件的接口），而不是依赖于各个组件具体的实现类。

## 2 类图 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5ncWl1bWluZw_size_16_color_FFFFFF_t_70 2]

## 3 代码 ##

Cpu

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

HardDisk

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

Memory

public interface Memory { 
        public void save();
    }

IntelCpu

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

KingstonMemory

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

XiJieHardDisk

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

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("计算机工作");
        }
    }

ComputerDemo

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

## 4 运行 ##

运行计算机
    使用希捷希捷硬盘取数据
    从硬盘上获取的数据是：数据
    使用Intel处理器
    使用金士顿内存条

## 5 说明 ##

面向对象的开发很好的解决了这个问题，一般情况下抽象的变化概率很小，让用户程序依赖于抽象，实现的细节也依赖于抽象。即使实现细节不断变动，只要抽象不变，客户程序就不需要变化。这大大降低了客户程序与实现细节的耦合度。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5ncWl1bWluZw_size_16_color_FFFFFF_t_70]: /images/20210724/b5e259322a394e459c6eadb29a75ef68.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5ncWl1bWluZw_size_16_color_FFFFFF_t_70 1]: /images/20210724/2f0d9a6da9fb4d23a5808232d9816256.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5ncWl1bWluZw_size_16_color_FFFFFF_t_70 2]: /images/20210724/ecacb2367f18427f9dc23f5515a8f204.png