2

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

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，以及 value，并包含三个参数构造函数，以及 setValue() 和 getValue()，但它们有不同的类型。

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

4

3 回答 3

4

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

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>>

Tis的边界Number & Comparable<T>，这意味着它必须同时是 a和a 。这样做是因为没有实现具有该方法的 ，但所有类（例如）都有，并且您需要该方法来检查方法中的参数范围。Number Comparable<T>NumberComparablecompareTo()java.lang.NumberIntegercompareTo()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); 
     }
}
于 2012-11-06T00:32:34.797 回答
1

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

    private Number value;

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

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

于 2012-11-06T00:23:21.113 回答
1

有几件事我想提一下

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

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

于 2012-11-06T00:29:54.453 回答