Get generic type of class at runtime

Question

How can I achieve this   public class GenericClass lt T gt        public Type getMyType                   How do I return the type of T            Everything I have tried so far always returns type Object rather than the specific type used

User · Answer

I found this to be a simple understandable and easily explainable  solution  public class GenericClass lt T gt         private Class classForT T   t            return t getClass   getComponentType               public static void main String   args            GenericClass lt String gt  g   new GenericClass lt String gt              System out println g classForT             System out println String class

User · Answer

Technique described in this article by Ian Robertson works for me   In short quick and dirty example    public abstract class AbstractDAO lt T extends EntityInterface  U extends QueryCriteria  V gt                    Method returns class implementing EntityInterface which was used in class        extending AbstractDAO                return Class lt T extends EntityInterface gt              public Class lt T gt  returnedClass                 return  Class lt T gt   getTypeArguments AbstractDAO class  getClass    get 0                         Get the underlying class for a type  or null if the type is a variable        type                 param type the type         return the underlying class             public static Class lt   gt  getClass Type type                if  type instanceof Class                return  Class  type            else if  type instanceof ParameterizedType                return getClass   ParameterizedType  type  getRawType               else if  type instanceof GenericArrayType                Type componentType     GenericArrayType  type  getGenericComponentType                Class lt   gt  componentClass   getClass componentType               if  componentClass    null                    return Array newInstance componentClass  0  getClass                  else                   return null                          else               return null                                  Get the actual type arguments a child class has used to extend a generic        base class                 param baseClass the base class         param childClass the child class         return a list of the raw classes for the actual type arguments              public static  lt T gt  List lt Class lt   gt  gt  getTypeArguments              Class lt T gt  baseClass  Class lt   extends T gt  childClass                Map lt Type  Type gt  resolvedTypes   new HashMap lt Type  Type gt             Type type   childClass             start walking up the inheritance hierarchy until we hit baseClass         while   getClass type  equals baseClass                 if  type instanceof Class                       there is no useful information for us in raw types  so just keep going                  type     Class  type  getGenericSuperclass                  else                   ParameterizedType parameterizedType    ParameterizedType  type                  Class lt   gt  rawType    Class  parameterizedType getRawType                     Type   actualTypeArguments   parameterizedType getActualTypeArguments                    TypeVariable lt   gt    typeParameters   rawType getTypeParameters                    for  int i   0  i  lt  actualTypeArguments length  i                          resolvedTypes put typeParameters i   actualTypeArguments i                                       if   rawType equals baseClass                         type   rawType getGenericSuperclass                                                          finally  for each actual type argument provided to baseClass  determine  if possible             the raw class for that type argument          Type   actualTypeArguments          if  type instanceof Class                actualTypeArguments     Class  type  getTypeParameters              else               actualTypeArguments     ParameterizedType  type  getActualTypeArguments                      List lt Class lt   gt  gt  typeArgumentsAsClasses   new ArrayList lt Class lt   gt  gt                resolve types by chasing down type variables          for  Type baseType   actualTypeArguments                while  resolvedTypes containsKey baseType                     baseType   resolvedTypes get baseType                             typeArgumentsAsClasses add getClass baseType                      return typeArgumentsAsClasses

User · Answer

You can t   If you add a member variable of type T to the class  you don t even have to initialise it   you could use that to recover the type

User · Answer

Here is my solution  The examples should explain it  The only requirement is that a subclass must set the generic type  not an object   import java lang reflect AccessibleObject  import java lang reflect Field  import java lang reflect Method  import java lang reflect ParameterizedType  import java lang reflect Type  import java lang reflect TypeVariable  import java util HashMap  import java util Map   public class TypeUtils             EXAMPLES           public static class Class1 lt A  B  C gt             public A someA          public B someB          public C someC           public Class lt   gt  getAType                 return getTypeParameterType this getClass    Class1 class  0                      public Class lt   gt  getCType                 return getTypeParameterType this getClass    Class1 class  2                        public static class Class2 lt D  A  B  E  C gt  extends Class1 lt A  B  C gt             public B someB          public D someD          public E someE             public static class Class3 lt E  C gt  extends Class2 lt String  Integer  Double  E  C gt             public E someE             public static class Class4 extends Class3 lt Boolean  Long gt                public static void test   throws NoSuchFieldException            Class4 class4   new Class4            Class lt   gt  typeA   class4 getAType       typeA   Integer         Class lt   gt  typeC   class4 getCType       typeC   Long          Field fieldSomeA   class4 getClass   getField  someA            Class lt   gt  typeSomeA   TypeUtils getFieldType class4 getClass    fieldSomeA      typeSomeA   Integer          Field fieldSomeE   class4 getClass   getField  someE            Class lt   gt  typeSomeE   TypeUtils getFieldType class4 getClass    fieldSomeE      typeSomeE   Boolean                   UTILS           public static Class lt   gt  getTypeVariableType Class lt   gt  subClass  TypeVariable lt   gt  typeVariable            Map lt TypeVariable lt   gt   Type gt  subMap   new HashMap lt  gt             Class lt   gt  superClass          while   superClass   subClass getSuperclass       null                 Map lt TypeVariable lt   gt   Type gt  superMap   new HashMap lt  gt                 Type superGeneric   subClass getGenericSuperclass                if  superGeneric instanceof ParameterizedType                     TypeVariable lt   gt    typeParams   superClass getTypeParameters                    Type   actualTypeArgs     ParameterizedType  superGeneric  getActualTypeArguments                     for  int i   0  i  lt  typeParams length  i                          Type actualType   actualTypeArgs i                       if  actualType instanceof TypeVariable                            actualType   subMap get actualType                                             if  typeVariable    typeParams i   return  Class lt   gt   actualType                      superMap put typeParams i   actualType                                               subClass   superClass              subMap   superMap                    return null             public static Class lt   gt  getTypeParameterType Class lt   gt  subClass  Class lt   gt  superClass  int typeParameterIndex            return TypeUtils getTypeVariableType subClass  superClass getTypeParameters   typeParameterIndex               public static Class lt   gt  getFieldType Class lt   gt  clazz  AccessibleObject element            Class lt   gt  type   null          Type genericType   null           if  element instanceof Field                type     Field  element  getType                genericType     Field  element  getGenericType              else if  element instanceof Method                type     Method  element  getReturnType                genericType     Method  element  getGenericReturnType                       if  genericType instanceof TypeVariable                Class lt   gt  typeVariableType   TypeUtils getTypeVariableType clazz   TypeVariable  genericType               if  typeVariableType    null                    type   typeVariableType                                   return type

User · Answer

I think there is another elegant solution   What you want to do is  safely   pass  the type of the generic type parameter up from the concerete class to the superclass   If you allow yourself to think of the class type as  metadata  on the class  that suggests the Java method for encoding metadata in at runtime   annotations   First define a custom annotation along these lines   import java lang annotation      Target ElementType TYPE   Retention RetentionPolicy RUNTIME  public  interface EntityAnnotation       Class entityClass        You can then have to add the annotation to your subclass    EntityAnnotation entityClass    PassedGenericType class  public class Subclass lt PassedGenericType gt          Then you can use this code to get the class type in  your base class   import org springframework core annotation AnnotationUtils         private Class getGenericParameterType         final Class aClass   this getClass        EntityAnnotation ne             AnnotationUtils findAnnotation aClass  EntityAnnotation class        return ne entityClass        Some limitations of this approach are    You specify the generic type  PassedGenericType  in TWO places rather than one which is non-DRY  This is only possible if you can modify the concrete subclasses

User · Answer

As others mentioned  it s only possible via reflection in certain circumstances   If you really need the type  this is the usual  type-safe  workaround pattern   public class GenericClass lt T gt          private final Class lt T gt  type        public GenericClass Class lt T gt  type              this type   type               public Class lt T gt  getMyType              return this type

User · Answer

This is my solution   import java lang reflect Type  import java lang reflect TypeVariable   public class GenericClass lt T extends String gt       public static void main String   args         for  TypeVariable typeParam   GenericClass class getTypeParameters            System out println typeParam getName           for  Type bound   typeParam getBounds               System out println bound

User · Answer

Here s one way  which I ve had to use once or twice   public abstract class GenericClass lt T gt       public abstract Class lt T gt  getMyType        Along with  public class SpecificClass extends GenericClass lt String gt         Override     public Class lt String gt  getMyType            return String class

User · Answer

It might be useful to someone  You can Use  java lang ref WeakReference  this way   class SomeClass lt N gt     WeakReference lt N gt  variableToGetTypeFrom     N getType        return variableToGetTypeFrom get

User · Answer

Here is my trick   public class Main        public static void main String   args  throws Exception            System out println Main  lt String gt  getClazz                 static  lt T gt  Class getClazz T    param             return param getClass   getComponentType

User · Answer

I have seen something like this  private Class lt T gt  persistentClass   public Constructor         this persistentClass    Class lt T gt     ParameterizedType  getClass                                getGenericSuperclass    getActualTypeArguments   0        in the hibernate GenericDataAccessObjects Example

User · Answer

One simple solution for this cab be like below  public class GenericDemo lt T gt       private T type       GenericDemo T t                this type   t             public String getType                 return this type getClass   getName               public static void main String   args                GenericDemo lt Integer gt  obj   new  GenericDemo lt Integer gt  5           System out println  Type     obj getType

User · Answer

To complete some of the answers here  I had to get the ParametrizedType of MyGenericClass  no matter how high is the hierarchy  with the help of recursion   private Class lt T gt  getGenericTypeClass             return  Class lt T gt    getParametrizedType getClass     getActualTypeArguments   0      private static ParameterizedType getParametrizedType Class clazz       if clazz getSuperclass   equals MyGenericClass class       check that we are at the top of the hierarchy         return  ParameterizedType  clazz getGenericSuperclass          else           return getParametrizedType clazz getSuperclass

User · Answer

I dont think you can  Java uses type erasure when compiling so your code is compatible with applications and libraries that were created pre-generics   From the Oracle Docs      Type Erasure      Generics were introduced to the Java language to provide tighter type   checks at compile time and to support generic programming  To   implement generics  the Java compiler applies type erasure to       Replace all type parameters in generic types with their bounds or   Object if the type parameters are unbounded  The produced bytecode    therefore  contains only ordinary classes  interfaces  and methods    Insert type casts if necessary to preserve type safety  Generate   bridge methods to preserve polymorphism in extended generic types    Type erasure ensures that no new classes are created for parameterized   types  consequently  generics incur no runtime overhead    http   docs oracle com javase tutorial java generics erasure html

User · Answer

Use Guava   import com google common reflect TypeToken  import java lang reflect Type   public abstract class GenericClass lt T gt      private final TypeToken lt T gt  typeToken   new TypeToken lt T gt  getClass           private final Type type   typeToken getType       or getRawType   to return Class lt   super T gt     public Type getType         return type         public static void main String   args        GenericClass lt String gt  example   new GenericClass lt String gt             System out println example getType          gt  class java lang String         A while back  I posted some full-fledge examples including abstract classes and subclasses here   Note  this requires that you instantiate a subclass of GenericClass so it can bind the type parameter correctly  Otherwise it ll just return the type as T

User · Answer

Here is my solution  public class GenericClass lt T gt        private Class lt T gt  realType       public GenericClass             findTypeArguments getClass                private void findTypeArguments Type t            if  t instanceof ParameterizedType                Type   typeArgs     ParameterizedType  t  getActualTypeArguments                realType    Class lt T gt   typeArgs 0             else               Class c    Class  t              findTypeArguments c getGenericSuperclass                          public Type getMyType                    How do I return the type of T   your question          return realType            No matter how many level does your class hierarchy has  this solution still works  for example   public class FirstLevelChild lt T gt  extends GenericClass lt T gt        public class SecondLevelChild extends FirstLevelChild lt String gt         In this case  getMyType     java lang String

User · Answer

Java generics are mostly compile time  this means that the type information is lost at runtime   class GenericCls lt T gt        T t      will be compiled to something like  class GenericCls      Object o      To get the type information at runtime you have to add it as an argument of the ctor   class GenericCls lt T gt         private Class lt T gt  type       public GenericCls Class lt T gt  cls                 type  cls              Class lt T gt  getType   return type       Example   GenericCls lt   gt  instance   new GenericCls lt String gt  String class   assert instance getType      String class

User · Answer

I did the same as  Moesio Above but in Kotlin it could be done this way   class A lt T   SomeClass gt           var someClassType   T      init        this someClassType    javaClass genericSuperclass as ParameterizedType  actualTypeArguments 0  as Class lt T gt

User · Answer

Sure  you can   Java does not use the information at run time  for backwards compatibility reasons   But the information is actually present as metadata and can be accessed via reflection  but it is still not used for type-checking    From the official API   http   download oracle com javase 6 docs api java lang reflect ParameterizedType html getActualTypeArguments 28 29  However  for your scenario I would not use reflection   I m personally more inclined to use that for framework code   In your case I would just add the type as a constructor param

User · Answer

Just in case you use store a variable using the generic type you can easily solve this problem adding a getClassType method as follows   public class Constant lt T gt      private T value      SuppressWarnings  unchecked     public Class lt T gt  getClassType          return   Class lt T gt   value getClass             I use the provided class object later to check if it is an instance of a given class  as follows   Constant lt   gt  constant        if  constant getClassType   equals Integer class         Constant lt Integer gt  integerConstant    Constant lt Integer gt  constant      Integer value   integerConstant getValue

User · Answer

public abstract class AbstractDao lt T gt        private final Class lt T gt  persistentClass       public AbstractDao                 this persistentClass    Class lt T gt     ParameterizedType  this getClass   getGenericSuperclass                     getActualTypeArguments   0

User · Answer

Generics are not reified at run-time  This means the information is not present at run-time   Adding generics to Java while mantaining backward compatibility was a tour-de-force  you can see the seminal paper about it  Making the future safe for the past  adding genericity to the Java programming language    There is a rich literature on the subject  and some people are dissatisfied with the current state  some says that actually it s a lure and there is no real need for it  You can read both links  I found them quite interesting

User · Answer

public static final Class lt   gt  getGenericArgument final Class lt   gt  clazz        return  Class lt   gt     ParameterizedType  clazz getGenericSuperclass    getActualTypeArguments   0

User · Answer

Here is working solution      SuppressWarnings  unchecked       private  Class lt T gt  getGenericTypeClass                 try                        String className     ParameterizedType  getClass   getGenericSuperclass    getActualTypeArguments   0  getTypeName                        Class lt   gt  clazz   Class forName className                       return   Class lt T gt   clazz                 catch   Exception e                        throw new  IllegalStateException  Class is not parametrized with generic type    Please use extends  lt  gt                             NOTES  Can be used only as superclass  1  Has to be extended with typed class   Child extends Generic lt Integer gt   OR  2  Has to be created as anonymous implementation  new Generic lt Integer gt

User · Answer

If you have a class like  public class GenericClass lt T gt        private T data     with T variable  then you can print T name  System out println data getClass   getSimpleName         quot String quot    quot Integer quot   etc

User · Answer

I used follow approach   public class A lt T gt         protected Class lt T gt  clazz       public A             this clazz    Class lt T gt     ParameterizedType  getClass   getGenericSuperclass    getActualTypeArguments   0              public Class lt T gt  getClazz             return clazz           public class B extends A lt C gt                     public void anything               here I may use getClazz

[java] Get generic type of class at runtime

Examples related to java

Examples related to generics

Examples related to reflection