Nhận loại chung của lớp khi chạy

Làm thế nào tôi có thể đạt được điều này?

public class GenericClass<T>
{
    public Type getMyType()
    {
        //How do I return the type of T?
    }
}

Tất cả mọi thứ tôi đã thử cho đến nay luôn trả về loại Objectchứ không phải loại cụ thể được sử dụng.

Như những người khác đã đề cập, nó chỉ có thể thông qua sự phản ánh trong một số trường hợp nhất định.

Nếu bạn thực sự cần loại, đây là mẫu giải pháp (loại an toàn) thông thường:

public class GenericClass<T> {

     private final Class<T> type;

     public GenericClass(Class<T> type) {
          this.type = type;
     }

     public Class<T> getMyType() {
         return this.type;
     }
}

Tôi đã thấy một cái gì đó như thế này

private Class<T> persistentClass;

public Constructor() {
    this.persistentClass = (Class<T>) ((ParameterizedType) getClass()
                            .getGenericSuperclass()).getActualTypeArguments()[0];
 }

trong ví dụ ngủ đông GenericDataAccessObjects

Generics không được thống nhất tại thời gian chạy. Điều này có nghĩa là thông tin không có mặt tại thời điểm chạy.

Thêm các khái quát vào Java trong khi duy trì khả năng tương thích ngược là một cách giải quyết (bạn có thể thấy bài báo quan trọng về nó: Làm cho tương lai an toàn cho quá khứ: thêm tính tổng quát vào ngôn ngữ lập trình Java ).

Có một tài liệu phong phú về chủ đề này, và một số người không hài lòng với tình trạng hiện tại, một số người nói rằng thực sự đó là một sự thu hút và không có nhu cầu thực sự cho nó. Bạn có thể đọc cả hai liên kết, tôi thấy chúng khá thú vị.

Sử dụng ổi.

import com.google.common.reflect.TypeToken;
import java.lang.reflect.Type;

public abstract class GenericClass<T> {
  private final TypeToken<T> typeToken = new TypeToken<T>(getClass()) { };
  private final Type type = typeToken.getType(); // or getRawType() to return Class<? super T>

  public Type getType() {
    return type;
  }

  public static void main(String[] args) {
    GenericClass<String> example = new GenericClass<String>() { };
    System.out.println(example.getType()); // => class java.lang.String
  }
}

Một thời gian trước, tôi đã đăng một số ví dụ đầy đủ bao gồm các lớp trừu tượng và các lớp con ở đây .

Lưu ý: đây yêu cầu bạn khởi tạo một lớp con của GenericClassđể nó có thể ràng buộc các tham số kiểu một cách chính xác. Nếu không, nó sẽ chỉ trả về kiểu như T.

Chắc chắn, bạn có thể.

Java không sử dụng thông tin trong thời gian chạy, vì lý do tương thích ngược. Nhưng thông tin thực sự hiện diện dưới dạng siêu dữ liệu và có thể được truy cập thông qua sự phản chiếu (nhưng nó vẫn không được sử dụng để kiểm tra kiểu).

Từ API chính thức:

http://doad.oracle.com/javase/6/docs/api/java/lang/reflect/ParameterizedType.html#getActualTypeArgument%28%29

Tuy nhiên , đối với kịch bản của bạn, tôi sẽ không sử dụng sự phản chiếu. Cá nhân tôi có xu hướng sử dụng nó cho mã khung. Trong trường hợp của bạn, tôi chỉ cần thêm kiểu như là một hàm tạo.

Java genericics chủ yếu là thời gian biên dịch, điều này có nghĩa là thông tin kiểu bị mất khi chạy.

class GenericCls<T>
{
    T t;
}

sẽ được biên dịch thành một cái gì đó như

class GenericCls
{
   Object o;
}

Để có được thông tin kiểu trong thời gian chạy, bạn phải thêm nó làm đối số của ctor.

class GenericCls<T>
{
     private Class<T> type;
     public GenericCls(Class<T> cls)
     {
        type= cls;
     }
     Class<T> getType(){return type;}
}

Thí dụ:

GenericCls<?> instance = new GenericCls<String>(String.class);
assert instance.getType() == String.class;

public abstract class AbstractDao<T>
{
    private final Class<T> persistentClass;

    public AbstractDao()
    {
        this.persistentClass = (Class<T>) ((ParameterizedType) this.getClass().getGenericSuperclass())
                .getActualTypeArguments()[0];
    }
}

Tôi đã sử dụng theo cách tiếp cận:

public class A<T> {

    protected Class<T> clazz;

    public A() {
        this.clazz = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
    }

    public Class<T> getClazz() {
        return clazz;
    }
}

public class B extends A<C> {
   /* ... */
    public void anything() {
       // here I may use getClazz();
    }
}

Tôi không nghĩ bạn có thể, Java sử dụng kiểu xóa khi biên dịch để mã của bạn tương thích với các ứng dụng và thư viện đã được tạo trước tiền chung.

Từ Tài liệu Oracle:

Loại tẩy

Generics đã được giới thiệu với ngôn ngữ Java để cung cấp các kiểm tra loại chặt chẽ hơn tại thời điểm biên dịch và để hỗ trợ lập trình chung. Để triển khai generic, trình biên dịch Java áp dụng kiểu xóa để:

Thay thế tất cả các tham số loại trong các loại chung bằng giới hạn hoặc Đối tượng của chúng nếu các tham số loại không bị ràng buộc. Do đó, mã byte được tạo ra chỉ chứa các lớp, giao diện và phương thức thông thường. Chèn phôi loại nếu cần thiết để bảo vệ an toàn loại. Tạo các phương thức cầu để bảo tồn tính đa hình trong các loại chung mở rộng. Kiểu xóa đảm bảo rằng không có lớp mới nào được tạo cho các kiểu tham số; do đó, generic không phát sinh thời gian chạy.

http://docs.oracle.com/javase/tutorial/java/generics/erasure.html

Kỹ thuật mô tả trong bài viết này của Ian Robertson làm việc cho tôi.

Trong ví dụ nhanh và bẩn:

 public abstract class AbstractDAO<T extends EntityInterface, U extends QueryCriteria, V>
 {
    /**
     * Method returns class implementing EntityInterface which was used in class
     * extending AbstractDAO
     *
     * @return Class<T extends EntityInterface>
     */
    public Class<T> returnedClass()
    {
        return (Class<T>) 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<?> 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<?> 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 <T> List<Class<?>> getTypeArguments(
            Class<T> baseClass, Class<? extends T> childClass)
    {
        Map<Type, Type> resolvedTypes = new HashMap<Type, Type>();
        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<?> rawType = (Class) parameterizedType.getRawType();

                Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
                TypeVariable<?>[] typeParameters = rawType.getTypeParameters();
                for (int i = 0; i < 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<Class<?>> typeArgumentsAsClasses = new ArrayList<Class<?>>();
        // 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;
    }
  }

Tôi nghĩ rằng có một giải pháp thanh lịch khác.

Những gì bạn muốn làm là (một cách an toàn) "chuyển" loại tham số loại chung lên từ lớp concerete sang lớp cha.

Nếu bạn cho phép mình nghĩ loại lớp là "siêu dữ liệu" trên lớp, điều đó gợi ý phương thức Java để mã hóa siêu dữ liệu trong thời gian chạy: chú thích.

Đầu tiên xác định một chú thích tùy chỉnh dọc theo các dòng này:

import java.lang.annotation.*;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface EntityAnnotation {
    Class entityClass();
}

Sau đó, bạn có thể phải thêm chú thích vào lớp con của mình.

@EntityAnnotation(entityClass =  PassedGenericType.class)
public class Subclass<PassedGenericType> {...}

Sau đó, bạn có thể sử dụng mã này để lấy loại lớp trong lớp cơ sở của mình:

import org.springframework.core.annotation.AnnotationUtils;
.
.
.

private Class getGenericParameterType() {
    final Class aClass = this.getClass();
    EntityAnnotation ne = 
         AnnotationUtils.findAnnotation(aClass, EntityAnnotation.class);

    return ne.entityClass();
}

Một số hạn chế của phương pháp này là:

1. Bạn chỉ định loại chung ( PassedGenericType) ở TWO thay vì loại không phải DRY.
2. Điều này chỉ có thể nếu bạn có thể sửa đổi các lớp con cụ thể.

Đây là giải pháp của tôi:

import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;

public class GenericClass<T extends String> {

  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);
      }
    }
  }
}

Đây là giải pháp làm việc !!!

@SuppressWarnings("unchecked")
    private Class<T> getGenericTypeClass() {
        try {
            String className = ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0].getTypeName();
            Class<?> clazz = Class.forName(className);
            return (Class<T>) clazz;
        } catch (Exception e) {
            throw new IllegalStateException("Class is not parametrized with generic type!!! Please use extends <> ");
        }
    } 

GHI CHÚ: Chỉ có thể được sử dụng như siêu lớp
1. Phải được mở rộng với lớp đã nhập ( Child extends Generic<Integer>)
HOẶC
2. Phải được tạo dưới dạng triển khai ẩn danh ( new Generic<Integer>() {};)

Bạn không thể. Nếu bạn thêm một biến thành viên loại T vào lớp (bạn thậm chí không phải khởi tạo nó), bạn có thể sử dụng biến đó để khôi phục loại.

Đây là một cách mà tôi phải sử dụng một hoặc hai lần:

public abstract class GenericClass<T>{
    public abstract Class<T> getMyType();
}

Cùng với

public class SpecificClass extends GenericClass<String>{

    @Override
    public Class<String> getMyType(){
        return String.class;
    }
}

Một giải pháp đơn giản cho chiếc taxi này như dưới đây

public class GenericDemo<T>{
    private T type;

    GenericDemo(T t)
    {
        this.type = t;
    }

    public String getType()
    {
        return this.type.getClass().getName();
    }

    public static void main(String[] args)
    {
        GenericDemo<Integer> obj = new  GenericDemo<Integer>(5);
        System.out.println("Type: "+ obj.getType());
    }
}

Để hoàn thành một số câu trả lời ở đây, tôi đã phải lấy ParametrienedType của MyGenericClass, bất kể thứ bậc cao đến đâu, với sự trợ giúp của đệ quy:

private Class<T> getGenericTypeClass() {
        return (Class<T>) (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());
    }
}

Đây là mẹo của tôi:

public class Main {

    public static void main(String[] args) throws Exception {

        System.out.println(Main.<String> getClazz());

    }

    static <T> Class getClazz(T... param) {

        return param.getClass().getComponentType();
    }

}

Chỉ trong trường hợp bạn sử dụng lưu trữ một biến bằng cách sử dụng loại chung, bạn có thể dễ dàng giải quyết vấn đề này bằng cách thêm phương thức getClassType như sau:

public class Constant<T> {
  private T value;

  @SuppressWarnings("unchecked")
  public Class<T> getClassType () {
    return ((Class<T>) value.getClass());
  }
}

Tôi sử dụng đối tượng lớp được cung cấp sau để kiểm tra xem nó có phải là một thể hiện của một lớp nhất định không, như sau:

Constant<?> constant = ...;
if (constant.getClassType().equals(Integer.class)) {
    Constant<Integer> integerConstant = (Constant<Integer>)constant;
    Integer value = integerConstant.getValue();
    // ...
}

Đây là giải pháp của tôi

public class GenericClass<T>
{
    private Class<T> realType;

    public GenericClass() {
        findTypeArguments(getClass());
    }

    private void findTypeArguments(Type t) {
        if (t instanceof ParameterizedType) {
            Type[] typeArgs = ((ParameterizedType) t).getActualTypeArguments();
            realType = (Class<T>) 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;
    }
}

Cho dù hệ thống phân cấp lớp của bạn có bao nhiêu cấp, giải pháp này vẫn hoạt động, ví dụ:

public class FirstLevelChild<T> extends GenericClass<T> {

}

public class SecondLevelChild extends FirstLevelChild<String> {

}

Trong trường hợp này, getMyType () = java.lang.String

public static final Class<?> getGenericArgument(final Class<?> clazz)
{
    return (Class<?>) ((ParameterizedType) clazz.getGenericSuperclass()).getActualTypeArguments()[0];
}

Đây là giải pháp của tôi. Các ví dụ nên giải thích nó. Yêu cầu duy nhất là một lớp con phải đặt loại chung, không phải là một đối tượng.

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<A, B, C> {

        public A someA;
        public B someB;
        public C someC;

        public Class<?> getAType() {
            return getTypeParameterType(this.getClass(), Class1.class, 0);
        }

        public Class<?> getCType() {
            return getTypeParameterType(this.getClass(), Class1.class, 2);
        }
    }

    public static class Class2<D, A, B, E, C> extends Class1<A, B, C> {

        public B someB;
        public D someD;
        public E someE;
    }

    public static class Class3<E, C> extends Class2<String, Integer, Double, E, C> {

        public E someE;
    }

    public static class Class4 extends Class3<Boolean, Long> {

    }

    public static void test() throws NoSuchFieldException {

        Class4 class4 = new Class4();
        Class<?> typeA = class4.getAType(); // typeA = Integer
        Class<?> typeC = class4.getCType(); // typeC = Long

        Field fieldSomeA = class4.getClass().getField("someA");
        Class<?> typeSomeA = TypeUtils.getFieldType(class4.getClass(), fieldSomeA); // typeSomeA = Integer

        Field fieldSomeE = class4.getClass().getField("someE");
        Class<?> typeSomeE = TypeUtils.getFieldType(class4.getClass(), fieldSomeE); // typeSomeE = Boolean


    }

    /*** UTILS ***/

    public static Class<?> getTypeVariableType(Class<?> subClass, TypeVariable<?> typeVariable) {
        Map<TypeVariable<?>, Type> subMap = new HashMap<>();
        Class<?> superClass;
        while ((superClass = subClass.getSuperclass()) != null) {

            Map<TypeVariable<?>, Type> superMap = new HashMap<>();
            Type superGeneric = subClass.getGenericSuperclass();
            if (superGeneric instanceof ParameterizedType) {

                TypeVariable<?>[] typeParams = superClass.getTypeParameters();
                Type[] actualTypeArgs = ((ParameterizedType) superGeneric).getActualTypeArguments();

                for (int i = 0; i < typeParams.length; i++) {
                    Type actualType = actualTypeArgs[i];
                    if (actualType instanceof TypeVariable) {
                        actualType = subMap.get(actualType);
                    }
                    if (typeVariable == typeParams[i]) return (Class<?>) actualType;
                    superMap.put(typeParams[i], actualType);
                }
            }
            subClass = superClass;
            subMap = superMap;
        }
        return null;
    }

    public static Class<?> getTypeParameterType(Class<?> subClass, Class<?> superClass, int typeParameterIndex) {
        return TypeUtils.getTypeVariableType(subClass, superClass.getTypeParameters()[typeParameterIndex]);
    }

    public static Class<?> getFieldType(Class<?> clazz, AccessibleObject element) {
        Class<?> 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<?> typeVariableType = TypeUtils.getTypeVariableType(clazz, (TypeVariable) genericType);
            if (typeVariableType != null) {
                type = typeVariableType;
            }
        }

        return type;
    }

}

Tôi đã làm giống như @Moesio ở trên nhưng trong Kotlin nó có thể được thực hiện theo cách này:

class A<T : SomeClass>() {

    var someClassType : T

    init(){
    this.someClassType = (javaClass.genericSuperclass as ParameterizedType).actualTypeArguments[0] as Class<T>
    }

}

Nó có thể hữu ích cho ai đó. Bạn có thể sử dụng java.lang.ref.WeakReference; cách này:

class SomeClass<N>{
  WeakReference<N> variableToGetTypeFrom;

  N getType(){
    return variableToGetTypeFrom.get();
  }
}

Tôi thấy đây là một giải pháp đơn giản dễ hiểu và dễ giải thích

public class GenericClass<T> {

    private Class classForT(T...t) {
        return t.getClass().getComponentType();
    }

    public static void main(String[] args) {
        GenericClass<String> g = new GenericClass<String>();

        System.out.println(g.classForT());
        System.out.println(String.class);
    }
}