如何使用 Java 泛型解决这种情况？

Question

I have the following class hierarchy:

public abstract class MyParentObject {}
public abstract class MyObject<T> extends MyParentObject {}

public abstract class MyParentContainer<T extends MyParentObject> {
    private Class<T> valueType;
    protected MyParentContainer(Class<T> valueType) {
        this.valueType = valueType;
    }
}
public abstract class MyObjectContainer<T extends MyObject<?>> extends MyParentContainer<T> {
    protected MyObjectContainer(Class<T> valueType) {
        super(valueType);
    }
}

This works fine so far. There are several subclasses of MyObject and several container classes having some of those subclasses as valueType , eg

public class IntObject extends MyObject<Integer> {}
public class IntContainer extends MyObjectContainer<IntObject> {
    public IntContainer() {
        super(IntObject.class);
    }
}

Now I need to implement a container though that works with a mixed set of subclasses of MyObject .

public class AllObjectContainer extends MyObjectContainer<MyObject<?>> {
    public AllObjectContainer() {
        super(MyObject.class); // compile error here
    }
}

This does not compile, because "The constructor MyObjectContainer<MyObject>(Class) is undefined". Casting `MyObject.class` to `Class>` is not possible.

To solve this, I could use raw types:

1. Change public class AllObjectContainer extends MyObjectContainer<MyObject<?>> to public class AllObjectContainer extends MyObjectContainer<MyObject>

This has consequences though because of type erasure, so I do not like this solution.

Alternatively I could enable casting by

1. Change protected MyObjectContainer(Class<T> valueType) { to protected MyObjectContainer(Class<? extends T> valueType) { (add ? extends )
2. Change super(MyObject.class) to super((Class<? extends MyObject<?>>) MyObject.class)

This method works, but the cast is marked as unchecked and changing the MyMiddleContainer -Constructor has potential side effects on other classes that extend it.

Are there any better solutions?

Answer 1

So, MyClass.class is of type Class<MyClass> not Class<MyClass<?>> .

This is really a question about reflection.

The usual good solution to the problem of reflection is not to use reflection.

I suggest removing the use of Class and replace with an interface of the operations you want. You can then, if you wish, place reflection nastiness within a particular implementation of that interface.

Answer 2

The comments about reflection and that this code is not the sign of the best implementation are true and valid and everyone who stumbles upon this answer should read and consider them .

Yet, in my case, it was not possible to get rid of the reflection altogether, because the Class value was passed on to another class that is not under my control - whether that is good is another question (I guess, the answer is 'no'), but not in the scope of this question.

I solved my problem in the following way:

1. removed the valueType parameter from the constructor
2. added protected abstract Class<T> getValueType(); to MyParentContainer

Then I implemented the method in the following ways:

public class IntContainer extends MyObjectContainer<IntObject> {
    protected Class<T> getValueType() {
        return IntObject.class;
    }
}

public class AllObjectContainer extends MyObjectContainer<MyObject<?>> {
    protected Class<T> getValueType() {
        return (Class<MyObject<?>>) (Class<?>) MyObject.class;
    }
}

The dual cast is not pretty, I am totally aware of that. Yet it is in a confined location, it is obvious that it is possible to cast and it fixes the "cannot cast" error.