如何在不违反 Liskov 替换原则的情况下在类之间有效地共享函数

Question

我有一个代码库，它最初是用许多不同的选项创建的，这些选项允许您让代码以稍微不同的方式执行相同的过程，如下所示：

public class MainFunction {
  public void main(String option){
     if (option.equals("vanilla mode")){
        this.firstFunction();
     }else{
        this.differentVersionOfFirstFunction();
     }
     this.secondFunction();
  }

  public void firstFunction(){
    //First functions code
  }

  public void secondFunction(){
     //Second functions code
  }

  public void differentVersionOfFirstFunction(){
     // different code from First functions code that produces the same type of end result using a slightly different method
  }
}

随着各种不同选项的添加和代码变得越来越复杂，这变得越来越复杂。

为了解决这个问题，我最初计划创建一个 Parent 对象，然后可以在需要时让孩子们在他们的 Parent 方法上有细微的不同变化。问题是我知道这会违反 Liskov 替换原则，实际上我可能有孩子应该共享他们父母可能不存在的相同方法。

所以我只能在同一个类对象中使用不同的方法，以稍微不同的方式完成相同的工作。

public class MainFunction {
  public void main1(){
    this.firstFunction();
    this.secondFunction();
  }

  public void main2(){
    this.differentVersionOfFirstFunction();
    this.secondFunction();
  }

  public void firstFunction(){
    //First functions code
  }

  public void secondFunction(){
    //Second functions code
  }

  public void differentVersionOfFirstFunction(){
    // different code from First functions code that produces the same type of end result using a slightly different method
  }
}

我想我可以创建一个单独的实用程序类来保存我所有的各种功能，但我不确定是否有更优雅的解决方案？

Answer 1

我看不出您的示例如何违反 Liskov 替换原则。然而，我看到的是它们可能违反了开放/封闭原则，这意味着每次你需要修改你的程序时，你编辑一些MainFunction.java文件并且有机会影响所有可能的场景运行程序。更好的解决方案是使用大量解耦的组件，这样当您需要修改某些内容时，您只需修改一小部分，这不太可能影响程序可能遇到的所有场景。这就是单一职责原则的意义所在。

正如另一个答案中提到的，您的方案似乎很适合应用策略模式。这可能如下所示：

1. 使用void main()方法创建接口MainFunction，不带任何选项。
2. 使用public abstract void main() 成员创建一个抽象策略类，例如AbstractMainFunction，不带任何选项。该类将实现MainFunction 接口。
3. 根据需要创建 AbstractMainFunction 的单独实现，例如VanillaModeMainFunction 和 DifferentMainFunction。您可能会发现在AbstractMainFunction 中保留一些共享代码很有用。

4. 创建一个策略切换器类，例如MainFunctionService。它将有一个方法，public void main(String option)，就像您的第一个示例一样，并且可能会有这样的 switch 语句：

   MainFunction strategy = defaultFunction;
   switch(option) {
       case "vanilla":
            strategy = vanillaFunction;
            break;
       case "different":
            strategy = differentFunction;
            break;
   }
   strategy.main();
   

看起来要做很多事情，但最终您会看到这如何真正简化维护和进一步开发。

Answer 2

也许您可以尝试使用策略模式，在您的 MainFunction 中注入您每次需要使用的 Strategy 对象。看看here