java - 类继承的数组值限制

Question

我正在编写信号处理库，
我想建立这种层次结构。

首先，我定义了抽象类
仅定义“此包装类具有一个 double[] 字段”
即

public abstract class DoubleArray{
    private final double[] array;
    DoubleArray(double[] array){
        this.array = array;
    }
}

(我将构造函数设为 package private 而不是 protected 因为
我想限制在包外使用构造函数)

(这里没有使用System.arraycopy
因为这个构造函数只有我用。)

接下来，我的第一个限制是，
“不能包含异常值”
即

//inside the same package
public class SignalWithoutExceptionalValues extends DoubleArray{
    SignalWithoutExceptionalValues(double[] signal){
        super(signal);
        for(double d : signal)
            if(Double.isNaN(d) || Double.isInfinite(d))
                throw new IllegalArgumentException("cannot contain exceptional values");
    }
}

下一个限制是
“信号在 -1.0 ~ 1.0 范围内”
即

//inside the same package
public final class OneAmplitudeSignal extends SignalWithoutExceptionalValues{
    OneAmplitudeSignal(double[] signal){
        super(signal);
        for(double d : signal)
            if(d > 1.0 || d < -1.0)
                throw new IllegalArgumentException("is not normalized");
    }
}

不过，我认为，
首先，
我必须做 for-each 参数检查，
然后，在那之后，
分配给字段。

但在这个例子中，
我被迫将未经检查的数组分配给字段，
因为 DoubleArray 构造函数必须初始化 array 字段。

所以，我的问题是，
有什么策略可以做到“先检查再分配”
在这种层次结构中。
或此设计不适合此目的，
还有另一个好的设计？

谢谢。

编辑

谢谢前两个答案。
但是通过这些解决方案，
库用户可以实例化“非法”信号，
因为“检查机制可以被覆盖”。

不过，我更喜欢继承
因为 OneAmplitudeSignal 对象可以是
分配给 SignalWithoutExceptionalValues 变量。
这个事实对应于 OneAmp~ 是 SignalWithout~ 的子集。

此外，幅度可以通过 someSignal instanceof OneAmplitudeSignal 检查。

这里不能使用“final”
因为我想允许图书馆用户
创建新的“更受限制的信号”
或者，“新类型的限制”。

此外，根类可以是非抽象。
在这种情况下，“无限制信号”也可以实例化。

Answer 1

您可以将检查逻辑提取到一个单独的 check 方法中，基本构造函数可以在赋值之前执行该方法:

public abstract class DoubleArray{
    private final double[] array;
    protected abstract void check (double[] array);
    DoubleArray(double[] array){
        check(array);
        this.array = array;
    }
}

子类将覆盖 check 以提供所需的验证逻辑:

public class SignalWithoutExceptionalValues extends DoubleArray{
    SignalWithoutExceptionalValues(double[] signal){
        super(signal);
    }

    @Override
    protected void check (double[] signal) {
        for(double d : signal)
            if(Double.isNaN(d) || Double.isInfinite(d))
                throw new IllegalArgumentException("cannot contain exceptional values");
    }
}

public final class OneAmplitudeSignal extends SignalWithoutExceptionalValues{
    OneAmplitudeSignal(double[] signal){
        super(signal);
    }

    @Override
    protected void check (double[] signal) {
        super.check ();
        for(double d : signal)
            if(d > 1.0 || d < -1.0)
                throw new IllegalArgumentException("is not normalized");
    }
}