使用策略或附加类？

Question

我有以下代码示例（代码如下）。

我有接口OnlyReverse 和OnlySplit，它们定义了对Data 类的操作。有时我的课程仅可用于倒车，有时我将能够进行倒车和拆分。

在代码中我有两种方法。

第一种方法是为这 2 个单独的用例 ReverseAndSplitImpl 和 OnlyReverseImpl 使用 2 个单独的类。在这里我不喜欢我需要额外的类，并且我需要在这两个类之间复制一些代码。

第二种方法是为两个用例SingleClassForReverseAndSplitImpl 使用一个类，然后使用策略注入NormalSplit 或NoSplit。这里我不喜欢这个额外的NoSplit 类，它基本上是人为的。

根据接口分离原则——我需要有ReverseAndSplit加入接口，还是应该总是分开使用两个接口（比如SingleClassForReverseAndSplitImpl implements OnlyReverse, OnlySplit而不是SingleClassForReverseAndSplitImpl implements ReverseAndSplit）？

从长远来看，其中哪种方法更好（将来更灵活）？

class Data{
  String a;
}

interface OnlyReverse{
  Data getData();
  OnlyReverse reverse();
}

interface OnlySplit{
  OnlySplit split();
}

interface ReverseAndSplit extends OnlyReverse, OnlySplit{
  @Override
  ReverseAndSplit reverse();
  @Override
  ReverseAndSplit split();
}

//------------------------- USE DISTINCT CLASSES; ONE HAS SPLIT OTHER NO

class ReverseAndSplitImpl implements ReverseAndSplit{
  Data data;

  public ReverseAndSplitImpl(Data data) {
    this.data = data;
  }

  @Override
  public Data getData() {
    return data;
  }

  @Override
  public ReverseAndSplit reverse() {
    //here reverse and return
    return new ReverseAndSplitImpl(data);
  }

  @Override
  public ReverseAndSplit split() {
    //here split and return
    return new ReverseAndSplitImpl(data);
  }
}

class OnlyReverseImpl implements OnlyReverse{
  Data data;

  public OnlyReverseImpl(Data data) {
    this.data = data;
  }

  @Override
  public Data getData() {
    return data;
  }

  @Override
  public OnlyReverse reverse() {
    return new OnlyReverseImpl(data);
  }
}

//------------------------- USE DISTINCT CLASSES; ONE HAS SPLIT OTHER NO

//------------------------- USE STRATEGY TO CHOOSE TO HAVE SPLITTING OR NO
interface SplitStrategy{
  Data split(Data data);
}
class NormalSplit implements SplitStrategy{
  @Override
  public Data split(Data data) {
    return new Data();
  }
}
//NullObject pattern
class NoSplit implements SplitStrategy{
  @Override
  public Data split(Data data) {
    return data;
  }
}

class SingleClassForReverseAndSplitImpl implements ReverseAndSplit{
  Data data;
  SplitStrategy splitStrategy;

  public SingleClassForReverseAndSplitImpl(Data data, SplitStrategy splitStrategy) {
    this.data = data;
    this.splitStrategy = splitStrategy;
  }

  @Override
  public Data getData() {
    return data;
  }

  @Override
  public ReverseAndSplit reverse() {
    //here reverse and return
    return new SingleClassForReverseAndSplitImpl(data, splitStrategy);
  }

  @Override
  public ReverseAndSplit split() {
    //here split and return
    SingleClassForReverseAndSplitImpl s = new SingleClassForReverseAndSplitImpl(data, splitStrategy);
    s.data = splitStrategy.split(data);
    return s;
  }
}
//------------------------- USE STRATEGY TO CHOOSE TO HAVE SPLITTING OR NO

public class Decorator {

  public static void main(String[] args) {

    ReverseAndSplit s11 = new SingleClassForReverseAndSplitImpl(new Data(), new NoSplit());
    s11 = s11.reverse();
    s11 = s11.split();  //has split operation, but NoSplit will do nothing

    OnlyReverse s12 = new OnlyReverseImpl(new Data());
    s12 = s12.reverse();
    //has no split operation present

    //Going from NoSplit to SplitAndReverse
    ReverseAndSplit s21 = new SingleClassForReverseAndSplitImpl(s11.getData(), new NormalSplit());
    s21 = s21.reverse();
    s21 = s21.split();  //has split and now it is using NormalSplit

    ReverseAndSplit s22 = new ReverseAndSplitImpl(s12.getData());
    s22 = s22.reverse();
    s22 = s22.split();

  }
}

Answer 1

我想使用您的第一种方法（两个更简单的接口）但不叫它们OnlyReverse 和OnlySplit 而是Reverse 和Split 是合理的。因此将它们组合起来是合理的，将来您也可以只使用其中之一。

但这也取决于您的域对象，因此很难为您做出选择。但我不会创建一个名为NoSplit 的接口，因为您仍然可以实现ReverseAndSplit 和 NoSplit，这对您来说毫无意义。

Answer 2

根据接口隔离原则，如果您有一个从不拆分的客户端，那么您不应向该客户端提供包含split 方法的接口。策略/空对象方法适用于有时需要拆分而其他时候不需要的单个客户。单独的接口方法适用于具有不同需求的两个不同的客户。