0

This is a follow-up to my question:

Create instance of generic type in Java when parameterized type passes through hierarchies?

For attempting to create a new generic from a contained class, I tried to adapt Steve B's approach of creating an anonymous subclass:

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

public class ParameterizedTypeEg {
    ParameterizedTypeEg () {
        ContainsParameterized<String> containString = new ContainsParameterized<String>();
    }
    public class Parameterized<E> {
        Parameterized () {
        }
        public Class<E> getTypeParameterClass() {
            Type type = getClass().getGenericSuperclass();
            ParameterizedType paramType = (ParameterizedType) type;
            return (Class<E>) paramType.getActualTypeArguments()[0];
        }
        public Constructor<E> getTypeParameterConstructor() {
            Constructor<E> constructor = null;
            try {
                constructor = getTypeParameterClass().getConstructor(QueriedColor.class);
            } catch (NoSuchMethodException e) { System.err.println(e); }
            return constructor;
        }           
    }
    class ContainsParameterized<E> {
        ContainsParameterized () {
            Parameterized<E> contained = new Parameterized<E>(){};
            try {
                E element = contained.getTypeParameterConstructor().newInstance();
            }
            catch (InstantiationException e) { System.err.println(e); }
            catch (IllegalAccessException e) { System.err.println(e); }
            catch (InvocationTargetException e) { System.err.println(e); }
        }
    }
    public static void main(String[] args) {
        new ParameterizedTypeEg();
    }
}

Please note the line Parameterized contained = new Parameterized(){};

Here I am attempting to create the anonymous subclass, as suggested by Steve B in the other post. However, I get a ClassCastException in the getTypeParameterClass() method. This is the same type of exception as in my other posting. That lead me to think that I could use the same solution as Steve B suggested for that problem.

Community
  • 1
  • 1
Jorocco
  • 83
  • 2
  • 9
  • What's the full stack trace? What is `paramType.getActualTypeArguments()[0]`? My suspicion is that it's a [`TypeVariable`](http://docs.oracle.com/javase/7/docs/api/). – Jeffrey Sep 01 '13 at 15:06
  • Here's the trace: Exception in thread "main" java.lang.ClassCastException: sun.reflect.generics.reflectiveObjects.TypeVariableImpl cannot be cast to java.lang.Class at mypackage.ParameterizedTypeEg$Parameterized.getTypeParameterClass(ParameterizedTypeEg.java:17) at mypackage.ParameterizedTypeEg$Parameterized.getTypeParameterConstructor(ParameterizedTypeEg.java:22) at mypackage.ParameterizedTypeEg$ContainsParameterized.(ParameterizedTypeEg.java:31) at mypackage.ParameterizedTypeEg.(ParameterizedTypeEg.java:9) at mypackage.ParameterizedTypeEg.main(ParameterizedTypeEg.java:39) – Jorocco Sep 01 '13 at 19:59

2 Answers2

0

The anonymous class must have the actual type parameter hard-coded in its declaration for it to work.

new Parameterized<E>(){};

does not work. You are just hard-coding "E" (a type variable). So when you look at the metadata using reflection all you see is "E" (a type variable).

You must create a subclass which hard-codes its superclass with an actual class as type argument at compile-time:

new Parameterized<String>(){};

I tried to adapt Steve B's approach of creating an anonymous subclass:

You missed the whole point of that. The point was not to create a subclass. The point was to create a subclass with the actual class of the type argument hard-coded in the superclass.

newacct
  • 119,665
  • 29
  • 163
  • 224
  • This doesn't really answer anything. It's basically just saying, "What you're doing doesn't work", and I already knew that when I posted. – Jorocco Sep 02 '13 at 16:12
  • @Jorocco: what did you expect? You're saying it doesn't work, and this is explaining why it doesn't work. – newacct Sep 02 '13 at 22:25
0

What you're trying to do can work so long as E is parameterized in a type definition somewhere. For example:

Parameterized<E> pe = new Parameterized<E>();

This will not allow you to resolve E since it's not part of a type definition. On the otherhand, this:

class StringE extends Parameterized<String> {}

or this:

Parameterized<String> ps = new Parameterized<String>(){};

will work since we're specifying the value of E as part of a type definition. To resolve the value of E, you might use TypeTools (which I authored):

Class<?> stringType = TypeResolver.resolveRawArgument(Parameterized.class, ps.getClass());
assert stringType == String.class;
Jonathan
  • 5,027
  • 39
  • 48