Как мне получить экземпляр класса универсального типа T?

У меня есть класс дженериков Foo<T>. В методе Fooя хочу получить экземпляр класса типа T, но я просто не могу вызвать T.class.

Какой предпочтительный способ обойти это, используя T.class?

Короткий ответ заключается в том, что нет способа узнать тип времени выполнения параметров универсального типа в Java. Я предлагаю прочитать главу о стирании типов в Учебном руководстве по Java для получения более подробной информации.

Популярное решение этого заключается в передаче Classпараметра типа в конструктор универсального типа, например

class Foo<T> {
    final Class<T> typeParameterClass;

    public Foo(Class<T> typeParameterClass) {
        this.typeParameterClass = typeParameterClass;
    }

    public void bar() {
        // you can access the typeParameterClass here and do whatever you like
    }
}

Я искал способ сделать это сам, не добавляя дополнительную зависимость к пути к классам. После некоторого исследования я обнаружил , что это возможно , до тех пор , пока у вас есть общий супертип. Это было нормально для меня, так как я работал со слоем DAO с универсальным супертипом слоя. Если это соответствует вашему сценарию, то это ИМХО самый подходящий подход.

В большинстве случаев использования дженериков, с которыми я сталкивался, есть какой-то универсальный супертип, например, List<T>для ArrayList<T>или GenericDAO<T>для DAO<T>и т. Д.

Чистое решение Java

В статье Доступ к универсальным типам во время выполнения в Java объясняется, как вы можете сделать это с помощью чистой Java.

@SuppressWarnings("unchecked")
public GenericJpaDao() {
  this.entityBeanType = ((Class) ((ParameterizedType) getClass()
      .getGenericSuperclass()).getActualTypeArguments()[0]);
}

Весеннее решение

Мой проект использовал Spring, что еще лучше, поскольку у Spring есть удобный метод для поиска типа. Это лучший подход для меня, так как выглядит лучше всего. Я думаю, если бы вы не использовали Spring, вы могли бы написать свой собственный служебный метод.

import org.springframework.core.GenericTypeResolver;

public abstract class AbstractHibernateDao<T extends DomainObject> implements DataAccessObject<T>
{

    @Autowired
    private SessionFactory sessionFactory;

    private final Class<T> genericType;

    private final String RECORD_COUNT_HQL;
    private final String FIND_ALL_HQL;

    @SuppressWarnings("unchecked")
    public AbstractHibernateDao()
    {
        this.genericType = (Class<T>) GenericTypeResolver.resolveTypeArgument(getClass(), AbstractHibernateDao.class);
        this.RECORD_COUNT_HQL = "select count(*) from " + this.genericType.getName();
        this.FIND_ALL_HQL = "from " + this.genericType.getName() + " t ";
    }

Однако есть небольшая лазейка: если вы определяете свой Fooкласс как абстрактный. Это будет означать, что вы должны создать свой класс как:

Foo<MyType> myFoo = new Foo<MyType>(){};

(Обратите внимание на двойные скобки в конце.)

Теперь вы можете получить тип Tво время выполнения:

Type mySuperclass = myFoo.getClass().getGenericSuperclass();
Type tType = ((ParameterizedType)mySuperclass).getActualTypeArguments()[0];

Однако обратите внимание, что mySuperclassэто должен быть суперкласс определения класса, фактически определяющий конечный тип для T.

Это также не очень элегантно, но вы должны решить, предпочитаете ли вы new Foo<MyType>(){}или new Foo<MyType>(MyType.class);в вашем коде.

Например:

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

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.NoSuchElementException;

/**
 * Captures and silently ignores stack exceptions upon popping.
 */
public abstract class SilentStack<E> extends ArrayDeque<E> {
  public E pop() {
    try {
      return super.pop();
    }
    catch( NoSuchElementException nsee ) {
      return create();
    }
  }

  public E create() {
    try {
      Type sooper = getClass().getGenericSuperclass();
      Type t = ((ParameterizedType)sooper).getActualTypeArguments()[ 0 ];

      return (E)(Class.forName( t.toString() ).newInstance());
    }
    catch( Exception e ) {
      return null;
    }
  }
}

Затем:

public class Main {
    // Note the braces...
    private Deque<String> stack = new SilentStack<String>(){};

    public static void main( String args[] ) {
      // Returns a new instance of String.
      String s = stack.pop();
      System.out.printf( "s = '%s'\n", s );
    }
}

Стандартный подход / обходной путь / решение заключается в добавлении classобъекта в конструктор (ы), например:

 public class Foo<T> {

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

    public Class<T> getType() {
      return type;
    }

    public T newInstance() {
      return type.newInstance();
    }
 }

Представьте, что у вас есть абстрактный суперкласс, который является общим:

public abstract class Foo<? extends T> {}

И затем у вас есть второй класс, который расширяет Foo универсальным Bar, расширяющим T:

public class Second extends Foo<Bar> {}

Вы можете получить класс Bar.classв классе Foo, выбрав Type(из ответа Берта Бруйнооха) и выведя его, используя Classэкземпляр:

Type mySuperclass = myFoo.getClass().getGenericSuperclass();
Type tType = ((ParameterizedType)mySuperclass).getActualTypeArguments()[0];
//Parse it as String
String className = tType.toString().split(" ")[1];
Class clazz = Class.forName(className);

Следует заметить, что эта операция не идеальна, поэтому рекомендуется кэшировать вычисленное значение, чтобы избежать многократных вычислений. Одно из типичных применений - это общая реализация DAO.

Окончательная реализация:

public abstract class Foo<T> {

    private Class<T> inferedClass;

    public Class<T> getGenericClass(){
        if(inferedClass == null){
            Type mySuperclass = getClass().getGenericSuperclass();
            Type tType = ((ParameterizedType)mySuperclass).getActualTypeArguments()[0];
            String className = tType.toString().split(" ")[1];
            inferedClass = Class.forName(className);
        }
        return inferedClass;
    }
}

Возвращаемое значение - Bar.class при вызове из класса Foo в другой функции или из класса Bar.

Вот рабочее решение:

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

ЗАМЕЧАНИЯ: Может использоваться только как суперкласс

1. Должен быть расширен типизированным классом ( Child extends Generic<Integer>)

ИЛИ

2. Должен быть создан как анонимная реализация ( new Generic<Integer>() {};)

Вы не можете сделать это из-за стирания типа. См. Также вопрос переполнения стека. Обобщения Java - стирание типов - когда и что происходит .

Лучшим маршрутом, чем класс, предложенный другими, является передача объекта, который может сделать то же, что вы сделали бы с классом, например, создать новый экземпляр.

interface Factory<T> {
  T apply();
}

<T> void List<T> make10(Factory<T> factory) {
  List<T> result = new ArrayList<T>();
  for (int a = 0; a < 10; a++)
    result.add(factory.apply());
  return result;
}

class FooFactory<T> implements Factory<Foo<T>> {
  public Foo<T> apply() {
    return new Foo<T>();
  }
}

List<Foo<Integer>> foos = make10(new FooFactory<Integer>());

У меня была эта проблема в абстрактном родовом классе. В данном конкретном случае решение проще:

abstract class Foo<T> {
    abstract Class<T> getTClass();
    //...
}

и позже производный класс:

class Bar extends Foo<Whatever> {
    @Override
    Class<T> getTClass() {
        return Whatever.class;
    }
}

У меня есть (некрасивое, но эффективное) решение этой проблемы, которое я использовал недавно:

import java.lang.reflect.TypeVariable;


public static <T> Class<T> getGenericClass()
{
    __<T> ins = new __<T>();
    TypeVariable<?>[] cls = ins.getClass().getTypeParameters(); 

    return (Class<T>)cls[0].getClass();
}

private final class __<T> // generic helper class which does only provide type information
{
    private __()
    {
    }
}

Возможно:

class Foo<T> {
  Class<T> clazz = (Class<T>) DAOUtil.getTypeArguments(Foo.class, this.getClass()).get(0);
}

Вам нужны две функции из hibernate-generic-dao / blob / master / dao / src / main / java / com / googlecode / genericdao / dao / DAOUtil.java .

Дополнительные сведения см. В разделе « Отражение обобщений» .

Я нашел общий и простой способ сделать это. В моем классе я создал метод, который возвращает универсальный тип в соответствии с его положением в определении класса. Давайте предположим, что определение класса выглядит так:

public class MyClass<A, B, C> {

}

Теперь давайте создадим некоторые атрибуты для сохранения типов:

public class MyClass<A, B, C> {

    private Class<A> aType;

    private Class<B> bType;

    private Class<C> cType;

// Getters and setters (not necessary if you are going to use them internally)

    } 

Затем вы можете создать универсальный метод, который возвращает тип на основе индекса универсального определения:

   /**
     * Returns a {@link Type} object to identify generic types
     * @return type
     */
    private Type getGenericClassType(int index) {
        // To make it use generics without supplying the class type
        Type type = getClass().getGenericSuperclass();

        while (!(type instanceof ParameterizedType)) {
            if (type instanceof ParameterizedType) {
                type = ((Class<?>) ((ParameterizedType) type).getRawType()).getGenericSuperclass();
            } else {
                type = ((Class<?>) type).getGenericSuperclass();
            }
        }

        return ((ParameterizedType) type).getActualTypeArguments()[index];
    }

Наконец, в конструкторе просто вызовите метод и отправьте индекс для каждого типа. Полный код должен выглядеть так:

public class MyClass<A, B, C> {

    private Class<A> aType;

    private Class<B> bType;

    private Class<C> cType;


    public MyClass() {
      this.aType = (Class<A>) getGenericClassType(0);
      this.bType = (Class<B>) getGenericClassType(1);
      this.cType = (Class<C>) getGenericClassType(2);
    }

   /**
     * Returns a {@link Type} object to identify generic types
     * @return type
     */
    private Type getGenericClassType(int index) {

        Type type = getClass().getGenericSuperclass();

        while (!(type instanceof ParameterizedType)) {
            if (type instanceof ParameterizedType) {
                type = ((Class<?>) ((ParameterizedType) type).getRawType()).getGenericSuperclass();
            } else {
                type = ((Class<?>) type).getGenericSuperclass();
            }
        }

        return ((ParameterizedType) type).getActualTypeArguments()[index];
    }
}

Как объяснялось в других ответах, чтобы использовать этот ParameterizedTypeподход, вам нужно расширить класс, но это кажется дополнительной работой, чтобы создать целый новый класс, который расширяет его ...

Таким образом, делая класс абстрактным, он заставляет вас расширять его, удовлетворяя, таким образом, требованиям подкласса. (используя @Getter Ломбока).

@Getter
public abstract class ConfigurationDefinition<T> {

    private Class<T> type;
    ...

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

Теперь, чтобы расширить его, не определяя новый класс. (Обратите внимание на {} в конце ... расширенный, но не перезаписывайте ничего - если не хотите).

private ConfigurationDefinition<String> myConfigA = new ConfigurationDefinition<String>(...){};
private ConfigurationDefinition<File> myConfigB = new ConfigurationDefinition<File>(...){};
...
Class stringType = myConfigA.getType();
Class fileType = myConfigB.getType();

Я предполагаю, что, поскольку у вас есть универсальный класс, у вас будет такая переменная:

private T t;

(эта переменная должна принимать значение в конструкторе)

В этом случае вы можете просто создать следующий метод:

Class<T> getClassOfInstance()
{
    return (Class<T>) t.getClass();
}

Надеюсь, поможет!

   public <T> T yourMethodSignature(Class<T> type) {

        // get some object and check the type match the given type
        Object result = ...            

        if (type.isAssignableFrom(result.getClass())) {
            return (T)result;
        } else {
            // handle the error
        }
   }

Если вы расширяете или реализуете какой-либо класс / интерфейс, использующий обобщенные типы, вы можете получить универсальный тип родительского класса / интерфейса, не изменяя вообще никакого существующего класса / интерфейса.

Там может быть три возможности,

Случай 1 Когда ваш класс расширяет класс, который использует Generics

public class TestGenerics {
    public static void main(String[] args) {
        Type type = TestMySuperGenericType.class.getGenericSuperclass();
        Type[] gTypes = ((ParameterizedType)type).getActualTypeArguments();
        for(Type gType : gTypes){
            System.out.println("Generic type:"+gType.toString());
        }
    }
}

class GenericClass<T> {
    public void print(T obj){};
}

class TestMySuperGenericType extends GenericClass<Integer> {
}

Случай 2, когда ваш класс реализует интерфейс, который использует Generics

public class TestGenerics {
    public static void main(String[] args) {
        Type[] interfaces = TestMySuperGenericType.class.getGenericInterfaces();
        for(Type type : interfaces){
            Type[] gTypes = ((ParameterizedType)type).getActualTypeArguments();
            for(Type gType : gTypes){
                System.out.println("Generic type:"+gType.toString());
            }
        }
    }
}

interface GenericClass<T> {
    public void print(T obj);
}

class TestMySuperGenericType implements GenericClass<Integer> {
    public void print(Integer obj){}
}

Случай 3 Когда ваш интерфейс расширяет интерфейс, который использует Generics

public class TestGenerics {
    public static void main(String[] args) {
        Type[] interfaces = TestMySuperGenericType.class.getGenericInterfaces();
        for(Type type : interfaces){
            Type[] gTypes = ((ParameterizedType)type).getActualTypeArguments();
            for(Type gType : gTypes){
                System.out.println("Generic type:"+gType.toString());
            }
        }
    }
}

interface GenericClass<T> {
    public void print(T obj);
}

interface TestMySuperGenericType extends GenericClass<Integer> {
}

Это довольно просто. Если вам нужно из одного класса:

Class clazz = this.getClass();
ParameterizedType parameterizedType = (ParameterizedType) clazz.getGenericSuperclass();
try {
        Class typeClass = Class.forName( parameterizedType.getActualTypeArguments()[0].getTypeName() );
        // You have the instance of type 'T' in typeClass variable

        System.out.println( "Class instance name: "+  typeClass.getName() );
    } catch (ClassNotFoundException e) {
        System.out.println( "ClassNotFound!! Something wrong! "+ e.getMessage() );
    }

На самом деле, я полагаю, у вас есть поле в вашем классе типа T. Если нет поля типа T, какой смысл иметь универсальный тип? Таким образом, вы можете просто сделать экземпляр этого поля.

В моем случае у меня есть

Список <T> элементов;

if (items.get (0) instanceof Locality) ...

Конечно, это работает, только если общее количество возможных классов ограничено.

Этот вопрос старый, но сейчас лучше всего использовать Google Gson.

Пример получить на заказ viewModel.

Class<CustomViewModel<String>> clazz = new GenericClass<CustomViewModel<String>>().getRawType();
CustomViewModel<String> viewModel = viewModelProvider.get(clazz);

Класс родового типа

class GenericClass<T>(private val rawType: Class<*>) {

    constructor():this(`$Gson$Types`.getRawType(object : TypeToken<T>() {}.getType()))

    fun getRawType(): Class<T> {
        return rawType as Class<T>
    }
}

Я хотел передать T.class методу, который использует Generics

Метод readFile читает файл .csv, указанный в fileName, с полным путем. Могут быть файлы csv с различным содержанием, поэтому мне нужно передать класс файла модели, чтобы я мог получить соответствующие объекты. Поскольку это чтение CSV-файла, я хотел сделать в общем. По тем или иным причинам ни одно из вышеперечисленных решений не помогло мне. Мне нужно использовать, Class<? extends T> typeчтобы это работало. Я использую библиотеку opencsv для анализа файлов CSV.

private <T>List<T> readFile(String fileName, Class<? extends T> type) {

    List<T> dataList = new ArrayList<T>();
    try {
        File file = new File(fileName);

        Reader reader = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
        Reader headerReader = new BufferedReader(new InputStreamReader(new FileInputStream(file)));

        CSVReader csvReader = new CSVReader(headerReader);
        // create csv bean reader
        CsvToBean<T> csvToBean = new CsvToBeanBuilder(reader)
                .withType(type)
                .withIgnoreLeadingWhiteSpace(true)
                .build();

        dataList = csvToBean.parse();
    }
    catch (Exception ex) {
        logger.error("Error: ", ex);
    }

    return dataList;
}

Вот как вызывается метод readFile

List<RigSurfaceCSV> rigSurfaceCSVDataList = readSurfaceFile(surfaceFileName, RigSurfaceCSV.class);

Я использую обходной путь для этого:

class MyClass extends Foo<T> {
....
}

MyClass myClassInstance = MyClass.class.newInstance();