这在实现多个接口时仍然遵循依赖倒置原则吗？答案

【问题标题】：Is this still follow Dependency Inversion Principle when implement multiple interface?这在实现多个接口时仍然遵循依赖倒置原则吗？
【发布时间】：2020-10-08 03:19:35
【问题描述】：

抱歉这个问题太长了，还有我的英语。

我正在阅读an article about DIP。我将这里的代码总结一下。

interface CoffeeMachine() {
    void brewFilterCoffee();
}

interface EspressoMachine() {
    void brewEspressoCoffee();
}

他们创建了两个不同的 CoffeeMachine。 BasicCoffeeMachine 和 PremiumCoffeeMachine。 它们都有相同的功能是 brewFilterCoffee(); 所以他们把它放在 CoffeeMachine 界面上

class BasicCoffeeMachine implements CoffeeMachine {
    @Override
    void brewFilterCoffee() {
        System.out.println("brewing filter coffee...");
    }
}

// this one can make Espresso
class PremiumCoffeeMachine implements CoffeeMachine, EspressoMachine {
    @Override
    void brewFilterCoffee() {
        System.out.println("brewing filter coffee but in premium way...");
    }

    @Override
    void brewEspressoCoffee() {
        System.out.println("brewing espresso coffee...");
    }
}

当他们创建 CoffeeApp 时，它在构造函数中接受 CoffeeMachine 接口并使用它来prepareCoffee()

class CoffeeApp {
    CoffeeMachine machine;
    
    public CoffeeApp(CoffeeMachine machine) {
        this.machine = machine;
    }
    
    public void prepareCoffee() {
        machine.brewFilterCoffee();
    }
}

在主类中。

class Main {
    public static void main(String[] args) {
        PremiumCoffeeMachine premiumCoffeeMachine = new PremiumCoffeeMachine();
        CoffeeApp app = new CoffeeApp(premiumCoffeeMachine);

        app.brewFilterCoffee();
    }
}

我在这里留下了困惑，因为他们没有提到他们如何在 CoffeeApp 中使用 brewEspressoCoffee()。所以我继续像这样修改 CoffeeApp：

class CoffeeApp {
    public void prepareFilterCoffee(CoffeeMachine machine) {
        machine.brewFilterCoffee();
    }
    
    public void prepareEspressoCoffee(EspressoMachine machine) {
        machine.brewEspressoCoffee();
    }
}

在 Main 类中，如果我想 brewEspressoCoffee()，我只需创建一个实现 EspressoMachine

的实例

class Main {
    public static void main(String[] args) {
        PremiumCoffeeMachine premiumCoffeeMachine = new PremiumCoffeeMachine();
        CoffeeApp app = new CoffeeApp();

        app.brewEspressoCoffee(premiumCoffeeMachine);
    }
}

这还是下面的DIP吗？还有比这个例子更好的方法吗？任何示例将不胜感激。

谢谢！！

【问题讨论】：

@Fildor 不要将 DI（依赖注入）与 DIP（依赖倒置原则）混淆，DIP 不谈论注入，而只是谈论 using an abstraction（例如 interface 像 @987654330 @) 而不是实际的实现（例如BasicCoffeeMachine）
感谢您的回复。 @Lino 那么我正确地遵循 DIP 了吗？
@ABC 我会这么说，因为CoffeApp 不依赖于实现（即class），而仅依赖于抽象（即interface）
我提到的 @Lino ... “并且依赖于顶部的具体类”.
@Lino ...但我错了。混淆了类的接口。

标签： java solid-principles dependency-inversion

【解决方案1】：

我想你已经抓住了 DIP 的精髓，那就是你可以总是插入一个接口来反转依赖的方向。

除了遵循DIP之外，这里还有信息隐藏的原理需要考虑。我们经常认为 IH 应用于数据，但它也适用于依赖项。

在原来的CoffeeApp中，客户端（客户）对EspressoMachine没有依赖，对CoffeeMachine有间接（传递）依赖。在修改后的CoffeeApp 中，客户端直接依赖于两个机器接口。

这些依赖是抽象的，所以满足DIP；但它引出了一个问题，如果CoffeeApp 将其依赖项暴露给它的客户，那么它的目的是什么？客户端可以直接调用这些依赖项。通过传递其依赖关系，CoffeeApp 变得无用。

【讨论】：