Over a million developers have joined DZone.

“When a class with type parameters is not a parameterized class” – a Java Generics Puzzler

· Java Zone

Learn more about the advantages of moving from a monolithic to microservices architecture.  Brought to you in partnership with IBM.

While recently fiddling with some more runtime generic type extraction for Deployit, I was caught out by some unexpected behaviour by the reflection API. A check of the Javadocs quickly revealed that I had once again been too hasty in relying on "common sense". Still, the case seems sufficiently unintuitive to merit discussion.

In this case, the issue centres on the interplay between Class.getTypeParameters and ParameterizedType. The gist of the code looks something like:

interface Spying {}

// small class hierarchy
class Person {}
class Professional<P> extends Person {}

class Agent extends Professional<Spying> {}
class Assassin extends Professional {}
class Bystander extends Person {}


Person jbond = new Agent();
System.out.println("Generic superclass type argument: " + tryGetSuperclassGenericTypeParam(jbond));

Person joepublic = new Bystander();
System.out.println("Generic superclass type argument: " + tryGetSuperclassGenericTypeParam(joepublic));

Person oddjob = new Assassin();
System.out.println("Generic superclass type argument: " + tryGetSuperclassGenericTypeParam(oddjob));


Type tryGetSuperclassGenericTypeParam(Object obj) {
Class<?> clazz = obj.getClass();
Class<?> superclass = clazz.getSuperclass();

// Elvis would be preferred, but for the sake of clarity...
if (superclass.getTypeParameters().length > 0) {
return ((ParameterizedType) clazz.getGenericSuperclass()).getActualTypeArguments()[0];
} else {
return null;


So...what happens?

tryGetSuperclassGenericTypeParam is where the action happens. It seems fairly straightforward: see if the object's superclass is generic (i.e. takes type parameters) and, if so, cast its Type representation to ParameterizedType to extract the actual value for the type parameter. If the superclass is not generic, simply return null.

When this code is run, the first two invocations of tryGetSuperclassGenericTypeParam result in the expected:

Generic superclass type argument: interface Spying
Generic superclass type argument: null

What about the third one? Well, given the fact that we've omitted to specify a generic type parameter for Professional we might assume1 that we'd also get null. The actual output, however, is:

Exception in thread "main" java.lang.ClassCastException: java.lang.Class cannot be cast to java.lang.reflect.ParameterizedType
at tryGetSuperclassGenericTypeParam(...)


In order to figure out what's going on here, let's have a look at the Javadoc for Class.getTypeParameters:

Returns an array of TypeVariable objects that represent the type variables declared by the generic declaration represented by this GenericDeclaration object, in declaration order. Returns an array of length 0 if the underlying generic declaration declares no type variables.

In other words, this is returning class-level information about the declaration of, in our case, the Professional class, which of course does have a type parameter.
However, if we look at Class.getGenericSuperclass2, which we invoke next, we find that it:

Returns the Type representing the direct superclass of the entity [...] represented by this Class.

If the superclass is a parameterized type, the Type object returned must accurately reflect the actual type parameters used in the source code.

Here, the information returned is specific to the actual declaration of the class, which may (or may not, as in our case) specify type paramaters for its superclass.

And therein lies the problem: Professional.class.getTypeArguments looks at the declaration of the Professional class, discovering a type argument, whereas Assassin.class.getGenericSuperclass looks at the occurrence of Professional in the declaration of Assassin and discovers no type parameters. Hence, it returns a Class rather than a ParameterizedType and blows up our code.


To cut a long story short: if an object's superclass has type arguments as determined by Class.getTypeArguments that does not mean that object.getClass().getGenericSuperclass() will be a ParameterizedType.

  1. Read "I assumed" ;-)
  2. It's a pity that Class.getGenericSignature, which determines the "generic or not" behaviour of Class.getGenericSuperclass, is private, native and undocumented.
  • Share/Bookmark


From http://blog.xebia.com/2010/04/22/when-a-class-with-type-parameters-is-not-a-parameterized-class-a-java-generics-puzzler/

From Idea to Application gives you the architecture to quickly build, manage and run a range of applications (web, mobile, big data, new smart devices, etc.) on an open-standard, cloud-based platform. See why developers are using IBM Bluemix. Brought to you in partnership with IBM.


The best of DZone straight to your inbox.

Please provide a valid email address.

Thanks for subscribing!

Awesome! Check your inbox to verify your email so you can start receiving the latest in tech news and resources.

{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}