1

我有几个非常相似的类（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();
}
4

2 回答 2

2

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

于 2012-04-30T19:45:34.827 回答
0

由于调用 ，不能用泛型的单个类替换它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);
  }
}
于 2012-05-03T12:34:03.157 回答