Question

I want to create an abstract Parameter class.

public abstract class Parameter{

}

I will have at least two subclasses:

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

}

and:

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

}

So all subclasses will require, the finals MIN and MAX, and value, and contain three argument constructors, and setValue() and getValue(), but they have different types.

How can I declare these variables in the abstract class?

Answer 1

You only need a single generic class with the correct type bound:

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

Explanation of <T extends Number & Comparable<T>>

The bound of T is Number & Comparable<T>, which means it must be both a Number and a Comparable<T>. This is done because Number does not implement Comparable, which has the compareTo() method, but all the java.lang.Number classes (eg Integer) do, and you need the compareTo() method to check parameter range in the setValue() method.

Without this special bound, you can’t check the range generically.

The other major change was to make min and max instance variables, rather than static ones. You might consider having some static min/max values to pass into the constructor, or to implement subclasses like this:

public class IntegerParameter extends Parameter<Integer> {

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