干燥这些类的最佳方法是什么，除了构造函数之外的所有内容都重复

Question

因此，我进行了一些重构，现在我的两个类除了构造函数之外看起来完全相同。

这些类包装了一个不太漂亮的 API 对象，并添加了一些属于 API 边缘的功能。

class A extends API {
  public A {
    this.APIOption = Option1;
    this.AnotherAPIOption = Option2;
    // a few more
  }

  public ArrayList<String> somethingTheAPIDoesntDo() {
    // Do something the API doesn't provide but I use alot
  }
  // Other shared methods
}

class B extends API {
  public B {
    this.APIOption = Option3;
    this.AnotherAPIOption = Option4;
    // a few more
  }

  public ArrayList<String> somethingTheAPIDoesntDo() {
    // Do something the API doesn't provide but I use alot
  }
  // Other shared methods
}

将两者之间的公共代码推送到抽象基类，并且让子类仅使用专门的选项设置实现其构造函数是否有意义？ 这在纸面上是有道理的，但有些感觉很奇怪/违反直觉。我在这里缺少模式吗？

可能的 DRYer 解决方案

class A extends BetterAPIBase {
  public A {
    this.APIOption = Option1;
    this.AnotherAPIOption = Option2;
    // a few more
  }
}

class B extends BetterAPIBase {
  public B {
    this.APIOption = Option3;
    this.AnotherAPIOption = Option4;
    // a few more
  }
}    

abstract class BetterAPIBase extends API {
  public Better APIBase() {}
  public ArrayList<String> somethingTheAPIDoesntDo() {
    // Do something the API doesn't provide but I use alot
  }
  // Other methods
}

编辑

静态工厂模式很好，但我想我也可以添加一个包含我添加的常用方法的接口。

我将使 BetterAPI 类也实现 IBetterAPI，这只会公开我在将实例类型声明为 IBetterAPI 时添加的方法。

interface IBetterAPI{
      public ArrayList<String> somethingTheAPIDoesntDo();
      // other methods I added in BetterAPI
}

//somewhere else:
IBetterAPI niceApi = BetterAPI.createWithOptionSetA();
niceApi.somethingTheAPIDoesntDo();

// Can't do this, nice and hidden.
niceApi.somethingBaseAPIDoes(string uglyOptions, bool adNauseum); 

Answer 1

拥有一个带有参数化（可能是私有）构造函数和多个静态工厂方法的类不是更简单吗？

class BetterAPI extends API {
  private BetterAPI(APIOption option, AnotherAPIOption anotherOption) {
    this.APIOption = option;
    this.AnotherAPIOption = anotherOption;
  }

  public static BetterAPI createWithOptionSetA() {
    return new BetterAPI(Option1, Option2);
  }

  public static BetterAPI createWithOptionSetB() {
    return new BetterAPI(Option3, Option4);
  }

  // ...
}

您问题的核心似乎是在同一个类中不能有多个无参数构造函数。静态工厂方法为此提供了一个很好的解决方案。

Answer 2

这与我要做的非常接近。尽管如果“再少一些”会在构造函数中产生大量冗余代码，我会写：

abstract class BetterAPIBase extends API { 
  public BetterAPIBase(String APIOption, int AnotherAPIOption, ... more ...) {
    this.APIOption=APIOption;
    this.AnotherAPIOption=AnotherAPIOption;
    // a few more
  } 
  public ArrayList<String> somethingTheAPIDoesntDo() { 
    // Do something the API doesn't provide but I use alot 
  } 
  // Other methods 
} 

class A extends BetterAPIBase { 
  public A { 
    super(Option1, Option2, ... more ...);
  } 
} 

class B extends BetterAPIBase { 
  public B { 
    super(Option3, Option4, ... more ...);
  } 
}     

当然，如果任何选项值相同，则不需要传递它们，这就是真正的冗余消除的地方会来的。