Question

我有几个非常相似的clases（FloatOperand，BooleanOperand，IntegerOperand）。它们只在被调用的“parse”方法（parseFloat，parseBoolean等）上有所区别 - 我可以只用一个GenericOperand类替换这个xxOperand类吗？（可能是泛型/反射组合）。

public class FloatOperand implements ConditionOperand {
 Float parsedNumber = 0.0f; 
 public FloatOperand parse(String aString) {
 if(!StringUtils.isEmpty(aString)) {
  parsedNumber = Float.parseFloat(aString);
 }
 return this;
}

public int compareTo(ConditionOperand arg) {
  Float someArg = (Float) arg.getWrappedToken();
  return parsedNumber.compareTo(someArg);
}

public Float getWrappedToken() {
    return this.parsedNumber;
}

/************/
public interface ConditionOperand extends Comparable<ConditionOperand> {
/**
 * @param aString
 *            - String representing a number, or a date, or a string.
 */
ConditionOperand parse(String aString);
Object getWrappedToken();
}

Answer 1

你真的在这里使用Float.parseFloat等不同的算法。所以从我从这几行看到的，单独的类似乎没问题。

Answer 2

由于Float.parseFloat()的调用，无法用泛型替换单个类，因此无法以通用方式完成。

但是你可以通过使用抽象类（而不是接口或除了接口之外）使用泛型来避免双重代码，以避免加倍代码，例如：

public class ConditionOperand<T extends Comparable<?>> implements Comparable<ConditionOperand<T>> {
  T parsedNumber; 
  public ConditionOperand<T> parse(String aString) {
    if(!StringUtils.isEmpty(aString)) {
      parsedNumber = simpleParse(aString);
    }
    return this;
  }

  public int compareTo(ConditionOperand arg) {
    T someArg = arg.getWrappedToken();
    return parsedNumber.compareTo(someArg);
  }

  public T getWrappedToken() {
    return this.parsedNumber;
  }

  public abstract T simpleParse(String s);
}

然后你有一些非常简单的实现子类，比如

public class FloatOperand implements ConditionOperand<Float> {
  public Float simpleParse(String s) {
    return Float.parseFloat(s);
  }
}

使用泛型来概括不同的实现

2 个答案: