实现多接口时是否仍然遵循依赖倒置原则？

Question

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

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

interface CoffeeMachine() {
    void brewFilterCoffee();
}

interface EspressoMachine() {
    void brewEspressoCoffee();
}

他们创建了两个不同的咖啡机。 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.

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 class 中，如果我想 brewEspressoCoffee()，我只需创建一个实现 EspressoMachine 的实例

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

        app.brewEspressoCoffee(premiumCoffeeMachine);
    }
}

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

谢谢！！

Answer 1

我认为您已经掌握了 DIP 的精髓，即您可以始终插入一个接口来反转依赖项的方向。

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

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

这些依赖是抽象的，所以DIP是满足的；但它回避了一个问题，如果 CoffeeApp 向其客户端公开其依赖项，那么它的目的是什么？客户端可以直接调用这些依赖项。通过传递其依赖项，CoffeeApp 变得无用。

实现多接口时是否仍然遵循依赖倒置原则？

Is this still follow Dependency Inversion Principle when implement multiple interface?

java

solid-principles

dependency-inversion