玩转设计模式：深入学习“依赖倒转原则”

先赞再看，养成习惯。

闲话少说，直入正题。今天由菜鸟给大家分享一下设计模式七大原则中的依赖倒转原则。

设计理念

1、上层模块不应该依赖下层模块，两者都应该依赖其抽象。
2、抽象不应该依赖细节，细节应该依赖抽象。

通过上面的两点我们不难发现，其实依赖倒转原则的核心思想就是“面向抽象”编程。这里的抽象可以是“接口”也可以是“抽象类”。

倒转的体现

打个比方，现在有一个出售水果的水果店系统需要开发。正常逻辑思考，第一步考虑是需要先有一个店，然后进一步考虑，要出售各种各样的水果。

用编程的术语来描述，此时的水果店就是上层模块，各种各样的水果就是下层模块。按上面的文字描述，我们可以将水果和水果店之间的依赖关系理解成下图。

按照以上描述我们编写代码。

未进行倒转的代码：

public class Test {

  public static void main(String[] args) {
    FruitShop fruitShop = new FruitShop();
    fruitShop.salesApple(new Apple());
    fruitShop.salesBanana(new Banana());
    fruitShop.salesWatermelon(new Watermelon());
    fruitShop.salesPeach(new Peach());
  }
}

// 水果店
class FruitShop {

  // 出售苹果
  public void salesApple(Apple apple) {
    System.out.println(apple.sales());
  }

  // 出售香蕉
  public void salesBanana(Banana banana) {
    System.out.println(banana.sales());
  }

  // 出售西瓜
  public void salesWatermelon(Watermelon watermelon) {
    System.out.println(watermelon.sales());
  }

  // 出售桃子
  public void salesPeach(Peach peach) {
    System.out.println(peach.sales());
  }
}

// 苹果
class Apple {

  public String sales() {
    return "卖出一斤苹果！";
  }
}

// 香蕉
class Banana {

  public String sales() {
    return "卖出一斤香蕉！";
  }
}

// 西瓜
class Watermelon {

  public String sales() {
    return "卖出一斤西瓜！";
  }
}

// 桃子
class Peach {

  public String sales() {
    return "卖出一斤桃子！";
  }
}

这样设计的程序比较容易理解，从上至下依次进行。但是它有一个巨大的缺点就是上层模块依赖于每一个下层模块，当下层模块变更时，会直接影响到上层。这是有问题的，作为一个水果店，我们肯定不会因为今天没有苹果了，就不再进行营业了对吧？

为此我们可以将一开始的想法“倒转”，从下层的水果开始思考，比如现在有苹果、香蕉、西瓜、等等……为了方便管理这些水果，我们可以抽象出一个“水果”接口（或抽象类）。然后让各类水果都依赖于这个接口，再让我们的水果店也依赖于这个接口。

其依赖关系如下图：

根据以上描述将之前的示例代码作出如下优化。

依赖倒转后的代码：

public class Test {

  public static void main(String[] args) {
    FruitShop fruitShop = new FruitShop();
    fruitShop.salesFruit(new Apple());
    fruitShop.salesFruit(new Banana());
    fruitShop.salesFruit(new Watermelon());
    fruitShop.salesFruit(new Peach());
  }
}

// 水果店
class FruitShop {

  // 出售水果
  public void salesFruit(Fruits fruits) {
    System.out.println(fruits.sales());
  }

}

// 抽象出的水果接口
interface Fruits {

  // 方法
  String sales();
}

// 苹果
class Apple implements Fruits {

  @Override
  public String sales() {
    return "卖出一斤苹果！";
  }
}

// 香蕉
class Banana implements Fruits {

  @Override
  public String sales() {
    return "卖出一斤香蕉！";
  }
}

// 西瓜
class Watermelon implements Fruits {

  @Override
  public String sales() {
    return "卖出一斤西瓜！";
  }
}

// 桃子
class Peach implements Fruits {

  @Override
  public String sales() {
    return "卖出一斤桃子！";
  }
}

讲了这么多，那依赖倒转到底有什么用那，或者说使用它有什么好处那？大家能通过上面的描述有一个自己的理解吗？

菜鸟认为依赖倒转有如下优点：

1、可以提高程序的稳定性。
2、有利于程序的扩展和优化。

以上就是今天跟大家分享的内容。如果文章哪里写的有问题的希望大家可以在评论区提出来，菜鸟会积修改。感觉文章写的还不错的记得点赞加关注呦！