Question

I have one supertype defined as:

public abstract class AType<T> {
        ....

    private T value;
    private T mask;

    public T getValue() {
        if (isMasking())
            return null;

        return this.value;
    }

    public void setValue(T value) {
        if (value == null)
            throw new IllegalArgumentException("Value is mandatory.");

        this.value = value;
    }

    protected T getMask() {
        if (!isMasking())
            return null;

        return this.mask;
    }

    protected void setMask(T mask) {
        if (mask == null)
            throw new IllegalArgumentException("Mask is mandatory.");

        this.setMasking(true);
        this.mask = mask;
    }
        ...
}

and few subtypes like:

public class SpecType extends AType<Integer> {
    ...
}

these sub types specifies the unknown parameter…. i have more f.e. IPv4, Long, and so on

now i need to somehow in runtime do a dynamic cast…
i have these classes defined in enum like this:

public enum Type {
    SOME_TYPE(new TypeID(0, (short) 0), OFMU16.class,
            new Instantiable<AType<?>>() {
                @Override
                public SpecType instantiate() {
                    return new SpecType(new OFMatchTypeIdentifier(0, (short) 0));
                }
            }),...;

    ...

    public Class<? extends AType<?>> toClass() {
    return this.clazz;
}

    ...

}

I want do something like:

AType<?> type = SOME_TYPE.newInstance();    //this works

SOME_TYPE.toClass().cast(type).setValue(10);    //this don't work

so I have to do it statically:

((SpecType) type).setValue(10);

Everything would be OK, but the user of this module will not want to look in enum and cast manually every time. This will probably make mistakes and spend a lot of time with debugging :/….

My question is how can I refactor this or how do I define structure of inheritance to allow user to cast dynamically? Is it possible?

Edit:
I am parsing packets from network. There is a lot types which differs in Vendor Type identifier and type of Value/Mask – these fields are all constant for every this combination, so i has defined it as enum constants. F.e. 20 have different only TypeID but same VendorID and all of them can be represented as Integer, next 10 differ in VendorID And TypeID but all of them can be represented as Short and so on.

Answer 1

It’s still not clear why you should have to cast at all. As soon as SOME_TYPE is written into your sourcecode OR the type of set setValue method is hardcoded (in your example int or Integer) you don’t need runtime checking – you need compile time checking.

So I suppose the following snippet is how your API users should code:

public class TypeTest {
    public static void main(String[] args) {
        AType<Integer> type0 = Types.SOME_TYPE_0.instantiate();
        type0.setValue(10);

        AType<String> type1 = Types.SOME_TYPE_1.instantiate();
        type1.setValue("foo");
    }
}

I have stripped down your example to the bare minimum which is required to understand the Generics part:

abstract class AType<T> {
    private T value;

    // standard getter/setter
    public T getValue() { return this.value; }
    public void setValue(T value) { this.value = value; }
}

class SpecTypeInt extends AType<Integer> {
}

class SpecTypeString extends AType<String> {
}

interface Instantiable<T> {
    T instantiate();
}

The key part is: Don’t use an enum, because an enum cannot have type parameters. You can use a plain interface instead like the next snippet. Each reference in the interface points to a factory. Each factory knows a) the abstract type and b) the concrete type. To make Generics happy you have to glue a) and b) together with ? extends X.

interface Types {
    Instantiable<? extends AType<Integer>> SOME_TYPE_0 = new Instantiable<SpecTypeInt>() {
        @Override
        public SpecTypeInt instantiate() {
            return new SpecTypeInt();
        }
    };

    Instantiable<? extends AType<String>> SOME_TYPE_1 = new Instantiable<SpecTypeString>() {
        @Override
        public SpecTypeString instantiate() {
            return new SpecTypeString();
        }
    }  ;
}

Cleanup: Must your user look into the interface: Yes, he must in any case, because he must know which is the appropriate type for setValue ¹. NO solution can circumvent this. Although Eclipse might help you and your users a little bit: In main just type Types.SOME_TYPE_1.instantiate(); then go to the start of the line, hit Ctrl2 + L (“Assign to loccal variable”) and Eclipse replaces the AType<String> instantiate = part for you.

---

¹If your users don’t know the right type for the setValue method, then you are asking the wrong question. In that case you should have asked something like “How to design a Generic safe conversion facility?”.