Question

我想创建一个抽象的参数类。

public abstract class Parameter{

}

我将至少有两个子类：

public class ParamDouble extends Parameter{
    public final double MIN;
    public final double MAX;
    private double value;

    public ParamDouble(double min, double max, double current){
         this.MIN = min; 
         this.MAX = max; 
         this.value = current; 
         }



    public void setValue(double v) {
        this.value = v;
        }
    public double getValue(){
        return this.value;
        }

}

和

public class ParamInt extends Parameter{
    public final int MIN;
    public final int MAX;
    private int value;

    public ParamDouble(int min, int max, int current){
         this.MIN = min; 
         this.MAX = max; 
         this.value = current; 
         }



    public void setValue(int v) {
        this.value = v;
        }
    public int getValue(){
        return this.value;
        }

}

因此所有子类都需要，韵母MIN和MAX，以及值，并包含三个参数构造函数，以及setValue（）和getValue（），但它们具有不同的类型。

如何在抽象类中声明这些变量？

Answer 1

您只需要一个具有正确类型绑定的通用类：

public class Parameter<T extends Number & Comparable<T>> {
    public final T min;
    public final T max;
    private T value;

    public Parameter(T min, T max, T current) {
        this.min = min; 
        this.max = max; 
        setValue(current); // Use setter to check range on construction 
    }

    public void setValue(T v) {
        // being Comparable, we can check the range generically
        if (max.compareTo(v) < 0) { 
            throw new IllegalArgumentException("Value exceeds " + max);
        }
        if (min.compareTo(v) > 0) {
            throw new IllegalArgumentException("Value is below " + min);
        }

        this.value = v;
    }

    public T getValue() {
        return this.value;
    }
}

`<T extends Number & Comparable<T>>`

的说明

T的界限是Number & Comparable<T>，这意味着它必须是Number 和 a Comparable<T>。这样做是因为Number没有实现Comparable，compareTo()方法，但所有java.lang.Number类（例如Integer）都有，你需要用于检查compareTo()方法中参数范围的setValue()方法。

如果没有此特殊限制，则无法一般性地检查范围。

另一个主要变化是制作min和max个实例变量，而不是static个变量。您可以考虑将一些静态最小/最大值传递给构造函数，或者实现这样的子类：

public class IntegerParameter extends Parameter<Integer> {

     public IntegerParameter(Integer current) {
         // specify a default min/max for the Integer impl
         super(-1, 999, current); 
     }
}

Answer 2

java.lang.Number 是 java.lang.Integer和java.lang.Double 的超类。只需将您的值类型设为Number。

    private Number value;

    public abstract void setValue(Number v);
    public abstract Number getValue();

但是你的静态最终变量 MIN 和 MAX 如果在抽象类中声明，你将无法继承它们在您的子类中，因为它们标记为静态最终。

Answer 3

我想提几件事

1）你应该看一下java泛型。这将是一个很好的候选人。

 public class Parameter<T extends Number> {
   private T value;

   public Parameter(T value) { this.value = value }

   public T getValue() { return value };
 }

然后我可以声明Double或Integer的参数。

 Parameter<Double> doubleParam = new Parameter<Double>(2.5);
 Parameter<Integer> intParam = new Parameter<Integer>(1);

2）我认为你不想在构造函数中设置MIN和MAX。这将允许您即时更改它。例如，考虑是否在允许设置之前检查了MIN和MAX，例如

 public void setValue(T value)
 {
    if (value < MIN || value > MAX) // error
    else
      this.value = value;
 }

现在我可以做一些古怪的事情

 Parameter<Integer> i1 = new Parameter<Integer>(0, 10, 4);
 i1.set(11); // this would error, until we did

 Parameter<Integer> i2 = new Parameter<Integer>(0, 15, 4);
 i1.set(11); // now it works

如果这就是你想要的，那很好 - 但似乎有点奇怪。您可能只想制作最小和最大常规（非静态）成员或以其他方式初始化它们。

用匿名类型声明一个抽象变量？

3 个答案:

`<T extends Number & Comparable<T>>`