使用策略还是其他课程？

问题描述

我有以下代码示例（下面的代码）。

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

在代码中，我有2种方法。

第一种方法是针对这两个单独的用例ReverseAndSplitImpl和OnlyReverseImpl使用2个单独的类。在这里，我不喜欢我需要附加的类，而不必在这两个类之间重复一些代码。

第二种方法是对两个用例SingleClassForReverseAndSplitImpl使用1类，然后使用策略注入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();

  }
}

解决方法

暂无找到可以解决该程序问题的有效方法，小编努力寻找整理中！

如果你已经找到好的解决方法，欢迎将解决方案带上本链接一起发送给小编。

小编邮箱:dio#foxmail.com (将#修改为@）