Question

我正在尝试定义一个抽象的Range类，它将作为许多范围类的基本实现。预期用途与此问题无关，但到目前为止，我有：

/**
 * Abstract generic utility class for handling ranges
 */
public abstract class Range<T extends Number> {

  // Variables to hold the range configuration
  private T start;
  private T stop;
  private T step;

  /**
   * Constructs a range by defining it's limits and step size.
   *
   * @param start The beginning of the range.
   * @param stop The end of the range.
   * @param step The stepping
   */
  public Range(T start, T stop, T step) {
    this.start = start;
    this.stop = stop;
    this.step = step;
  }
}

现在我想添加一个构造函数，只需要start和stop，并设置默认步长值1，无论Number {的实现是什么{ {1}}是（例如，如果T T Integer的值为[one]，而1为T {{1将具有值Long，依此类推）。我想要像：

[one]

但是我无法弄清楚如何设置1L的值。由于Java对我来说还是一个新手，我尝试过：

protected Range(T start, T stop) {
  this(start, stop, [one]);
}

不起作用，因为在[one]的实例化中明显定义了private static final T one = 1;。我也试过了：

也不起作用，因为在Range.this加上protected static abstract T getOne();和T的实例化中Range.this定义了static。

无论实现abstract [one]的实现是什么，我都需要一些方法来扩展类以强制定义Number的值。

最终我还想将零值设置为默认开始，这样我得到一个如下所示的构造函数：

Range

Answer 1

一种解决方案是询问子类使用的默认步骤：

public abstract class Range<T extends Number> {

    private T start;
    private T stop;
    private T step;

    public Range(T start, T stop, T step) {
        this.start = start;
        this.stop = stop;
        this.step = step;
    }

    protected Range(T start, T stop) {
        this.start = start;
        this.stop = stop;
        this.step = getDefaultStep();
    }

    protected abstract T getDefaultStep();

}

public class IntegerRange extends Range<Integer> {

    public IntegerRange(Integer start, Integer stop, Integer step) {
        super(start, stop, step);
    }

    public IntegerRange(Integer start, Integer stop) {
        super(start, stop);
    }

    @Override
    protected Integer getDefaultStep() {
        return 1;
    }

}

public class DoubleRange extends Range<Double> {

    public DoubleRange(Double start, Double stop, Double step) {
        super(start, stop, step);
    }

    public DoubleRange(Double start, Double stop) {
        super(start, stop);
    }

    @Override
    protected Double getDefaultStep() {
        return 1d;
    }

}

Answer 2

您可以使用此实现：

protected Range(T start, T stop) {
  this(start, stop, (T) (new Integer(1)));
}

Answer 3

你会遇到另一个问题......但这是你的号码1：

Number ONE = new Number() {
    @Override
    public int intValue() {
        return 1;
    }

    @Override
    public long longValue() {
        return 1L;
    }

    @Override
    public float floatValue() {
        return 1.0f;
    }

    @Override
    public double doubleValue() {
        return 1.0;
    }

    @Override
    public byte byteValue() {
        return 1;
    }

    @Override
    public short shortValue() {
        return 1;
    }
};

具有默认值的抽象类

3 个答案: