Thread: Proper way to cast generics?

Every once in awhile you run into that bit of generics code that no matter what you do you can't get the code to behave without a forced cast. This is often due to the fact that generics are implemented through type erasure and don't exist at runtime. What I was wondering is why do my casts sometimes come up as syntax error requiring me to remove generic types from them?

For example; (These are all static members of a class with no generic type)

private static final Map<Class<? extends Event>, Collection<EventHandler<? extends Event>>> EVENT_HANDLERS = ...
 
static <T extends Event> Collection<EventHandler<T>> getHandlers(Class<T> eventType) {
	return (Collection) EVENT_HANDLERS.get(eventType);
}

The cast above is of type (Collection). I want it to actually be of type (Collection<EventHandler<T>>) but when I add that generic info on it becomes a syntax error. Why is this?

Also is there a way to achieve the desired relationship here without resorting to casts? That relationship being that the map EVENT_HANDLERS contains a bunch of entries, each entry having a key that is a class subtype of event and a corresponding value of an EventHandler of that same event type.

I.E. <T extends Event> Map<Class<T>, Collection<EventHandler<T>>> *only that the T is a different subclass of Event for every entry.

As far as I'm aware the Java generic system is not powerful enough to express this concept directly.

The problem is that the type of the value of the map is the wildcarded type Collection<EventHandler<? extends Event>>. To this type you can cast. When you write your method, it returns a concrete type, the T which is contracted by the parameter. But java cannot determine if the value fetched by the key-value Class<T> would have the appropriate type. There exists no correlation between the key and the value. If you use wildcards and you want retrieve concrete types from any wildcarded type you must always cast. The bounded wildcard is for writing a common contract like an abstract class or an interface.

Look also at this and this and this.

A way to implement your relationship would be a structure like this:

	class Example<E extends Event> {
		private Class<E> clazz;
		private Collection<EventHandler<E>> collection;
	}

Also you can first use an upper common type and then make a cast to concrete type:

	static <T extends Event, E extends T> Collection<EventHandler<T>> getHandlers(Class<T> eventType) {
 
		Collection<?> col =  EVENT_HANDLERS.get(eventType);
		return (Collection<EventHandler<T>>)col;
	}

Actual it's not a solution for your problem