具有默认值的抽象类

default-value java abstract-class abstract

2022-09-03 01:06:45

我正在尝试定义一个抽象的 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;
  }
}

现在我想添加一个构造函数，它只接受和，并设置一个默认的步长值，无论的实现是什么（例如，if is 将具有值，如果 is 将具有值，依此类推）。我想要这样的东西：startstop1NumberTTInteger[one]1TLong[one]1L

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

但是我不知道如何设置.由于Java对我来说还很陌生，所以我尝试了：[one]

private static final T one = 1;

这不起作用，因为在的实例化中明显定义了。我也试过：TRange.this

protected static abstract T getOne();

这也不起作用，因为在 plus 的实例化中定义了它，并且不能一起工作。TRange.thisstaticabstract

我需要一些方法来强制扩展类来定义值，无论实现什么实现。[one]NumberRange

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

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

答案 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;
    }

}

答案 2

您可以使用此实现：

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