Declare an abstract variable with anonymous type?

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?

Do you mean to have MIN and MAX be static? By your constructor, this seems to be a mistake. — Joe, Nov 06 '12 at 00:26

Bohemian · Accepted Answer · 2012-11-06T00:43:16.123

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

Any suggestions for how I'd go about it if I wanted an enum as a parameter? — dwjohnston, Nov 07 '12 at 03:49
What exactly to you mean? An enum that implements `Comparable`? If so, use `Parameter & Comparable>`. Otherwise let me know what you have in mind. — Bohemian, Nov 07 '12 at 07:05
Ok, the problem I'm really having with this approach, is that I later run into the trouble with trying to find what the generic type is. Relevant thread: http://stackoverflow.com/questions/1004022/java-generic-class-determine-type — dwjohnston, Nov 09 '12 at 00:24
^Solved that problem using [this method](http://stackoverflow.com/questions/182636/how-to-determine-the-class-of-a-generic-type). Still, pretty ugly. — dwjohnston, Nov 09 '12 at 01:19

PermGenError · Answer 2 · 2012-11-06T00:28:30.440

1

java.lang.Number is the super class of java.lang.Integer and java.lang.Double. just make your value type as Number.

    private Number value;

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

but your static final variables MIN and MAX if declared in the abstract class, you wont be able to inherit them in your subclass, because of they are marked static final.

edited Nov 06 '12 at 00:28

answered Nov 06 '12 at 00:23

PermGenError

45,977
8
87
106

jeff · Answer 3 · 2012-11-06T00:56:27.560

There's a few things I would like to mention

1) You should look at java generics. This would be a good candidate for it.

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

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

   public T getValue() { return value };
 }

Then I can declare Parameters of Double or Integer.

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

2) I don't think you want to set MIN and MAX in your constructor. That will allow you to change it on the fly. For example, consider if you checked MIN and MAX before you allowed set, like

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

Now I could do something wacky like

 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

If that's what you want, then fine - but it seems a little odd. You might just want to make min and max regular (non-static) members or initialize them some other way.

-1 `value < MIN or value > MAX` is a compile error. A type bound of `` won't help you to check if value is within range. — Bohemian, Nov 06 '12 at 00:44

Declare an abstract variable with anonymous type?

3 Answers3

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

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