Jak uzyskać instancję klasy ogólnego typu T?

Mam klasy leków generycznych Foo<T>. W metodzie Foochcę uzyskać instancję klasy typu T, ale po prostu nie mogę wywoływać T.class.

Jaki jest preferowany sposób obejścia tego problemu T.class?

Krótka odpowiedź brzmi, że nie ma sposobu, aby dowiedzieć się, jakie parametry wykonawcze mają ogólne parametry typu w Javie. Sugeruję przeczytanie rozdziału o usuwaniu czcionek w samouczku Java, aby uzyskać więcej informacji.

Popularnym rozwiązaniem tego jest przekazanie Classparametru typu do konstruktora typu ogólnego, np

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

Szukałem sposobu na zrobienie tego sam, bez dodawania dodatkowej zależności do ścieżki klas. Po pewnym dochodzeniu stwierdziłem, że jest to możliwe, dopóki masz ogólny nadtyp. Było to dla mnie OK, ponieważ pracowałem z warstwą DAO z nadtypem warstwy ogólnej. Jeśli to pasuje do twojego scenariusza, to jest to najładniejsze podejście IMHO.

Większość ogólnych przypadków użycia, z którymi się spotkałem, ma jakiś rodzaj ogólny, np. List<T>Dla ArrayList<T>lub GenericDAO<T>dlaDAO<T> itp.

Rozwiązanie Pure Java

Artykuł Uzyskiwanie dostępu do typów ogólnych w środowisku wykonawczym w Javie wyjaśnia, jak to zrobić za pomocą czystej Java.

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

Wiosenne rozwiązanie

Mój projekt wykorzystywał Spring, co jest jeszcze lepsze, ponieważ Spring ma przydatną metodę użyteczną do znalezienia tego typu. Jest to dla mnie najlepsze podejście, ponieważ wygląda najładniej. Myślę, że gdybyś nie używał Springa, mógłbyś napisać własną metodę narzędzia.

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

Istnieje jednak niewielka luka: jeśli zdefiniujesz swoją Fooklasę jako abstrakcyjną. Oznaczałoby to, że musisz stworzyć swoją klasę jako:

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

(Zwróć uwagę na podwójne nawiasy klamrowe na końcu.)

Teraz możesz pobrać typ Tw czasie wykonywania:

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

Zauważ jednak, że mySuperclassmusi to być nadklasa definicji klasy, która faktycznie określa ostateczny typ T.

Nie jest również zbyt elegancki, ale musisz zdecydować, czy wolisz, new Foo<MyType>(){}czy new Foo<MyType>(MyType.class);w swoim kodzie.

Na przykład:

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

Następnie:

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

Standardowym podejściem / obejściem / rozwiązaniem jest dodanie classobiektu do konstruktora (-ów), na przykład:

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

Wyobraź sobie, że masz abstrakcyjną nadklasę, która jest ogólna:

public abstract class Foo<? extends T> {}

A potem masz drugą klasę, która rozszerza Foo za pomocą ogólnego paska, który rozszerza T:

public class Second extends Foo<Bar> {}

Możesz uzyskać klasę Bar.classw klasie Foo, wybierając Type(z odpowiedzi bert bruynooghe) i wnioskując ją za pomocą Classinstancji:

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

Trzeba pamiętać, że ta operacja nie jest idealna, dlatego dobrym pomysłem jest buforowanie obliczonej wartości, aby uniknąć wielokrotnych obliczeń. Jednym z typowych zastosowań jest ogólna implementacja DAO.

Ostateczne wdrożenie:

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

Zwracana wartość to Bar.class po wywołaniu z klasy Foo w innej funkcji lub z klasy Bar.

Oto działające rozwiązanie:

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

UWAGI: Może być używany tylko jako nadklasa

1. Musi zostać rozszerzony o typ klasowy ( Child extends Generic<Integer>)

LUB

2. Musi zostać utworzony jako anonimowa implementacja ( new Generic<Integer>() {};)

Nie możesz tego zrobić z powodu usunięcia typu. Zobacz także Pytanie o przepełnienie stosu Generics Java - usuwanie typu - kiedy i co się dzieje .

Lepszą drogą niż klasą, którą sugerowali inni, jest przejście do obiektu, który może zrobić to, co zrobiłbyś z klasą, np. Utworzyć nową instancję.

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

Miałem ten problem w abstrakcyjnej klasie ogólnej. W tym konkretnym przypadku rozwiązanie jest prostsze:

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

a później klasa pochodna:

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

Mam (brzydkie, ale skuteczne) rozwiązanie tego problemu, z którego ostatnio korzystałem:

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 __()
    {
    }
}

To jest możliwe:

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

Potrzebujesz dwóch funkcji z hibernacji-generic-dao / blob / master / dao / src / main / java / com / googlecode / genericdao / dao / DAOUtil.java .

Aby uzyskać więcej wyjaśnień, zobacz Odbicie ogólnych .

Znalazłem ogólny i prosty sposób na zrobienie tego. W mojej klasie stworzyłem metodę, która zwraca typ ogólny zgodnie z jego pozycją w definicji klasy. Załóżmy taką definicję klasy:

public class MyClass<A, B, C> {

}

Teraz utwórzmy niektóre atrybuty, aby zachować typy:

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)

    } 

Następnie możesz utworzyć ogólną metodę, która zwraca typ na podstawie indeksu ogólnej definicji:

   /**
     * 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];
    }

Na koniec w konstruktorze wystarczy wywołać metodę i wysłać indeks dla każdego typu. Cały kod powinien wyglądać następująco:

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

Jak wyjaśniono w innych odpowiedziach, użyj tego ParameterizedType podejście, musisz rozszerzyć klasę, ale wydaje się to dodatkową pracą, aby stworzyć zupełnie nową klasę, która ją rozszerza ...

Tak więc abstrakcja klasy zmusza cię do jej rozszerzenia, spełniając w ten sposób wymóg podklasy. (używając @Getter lomboka).

@Getter
public abstract class ConfigurationDefinition<T> {

    private Class<T> type;
    ...

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

Teraz, aby go rozszerzyć bez definiowania nowej klasy. (Uwaga {} na końcu ... rozszerzone, ale nie zastępuj niczego - chyba że chcesz).

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

Zakładam, że skoro masz klasę ogólną, miałbyś taką zmienną:

private T t;

(ta zmienna musi przyjąć wartość w konstruktorze)

W takim przypadku możesz po prostu utworzyć następującą metodę:

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

Mam nadzieję, że to pomoże!

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

Jeśli rozszerzasz lub implementujesz dowolną klasę / interfejs, który używa ogólnych, możesz uzyskać Ogólny typ klasy / interfejsu nadrzędnego, bez modyfikowania żadnej istniejącej klasy / interfejsu.

Mogą być trzy możliwości,

Przypadek 1 Gdy twoja klasa rozszerza klasę, która używa 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> {
}

Przypadek 2 Gdy twoja klasa implementuje interfejs korzystający z 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){}
}

Przypadek 3 Gdy interfejs rozszerza interfejs korzystający z 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> {
}

To całkiem proste. Jeśli potrzebujesz z tej samej klasy:

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

Właściwie przypuszczam, że masz pole w swojej klasie typu T. Jeśli nie ma pola typu T, po co mieć ogólny typ? Możesz więc po prostu zrobić instancję na tym polu.

W moim przypadku mam

Wyświetl elementy <T>;

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

Oczywiście działa to tylko wtedy, gdy całkowita liczba możliwych klas jest ograniczona.

To pytanie jest stare, ale teraz najlepsze jest korzystanie z Google Gson .

Przykład uzyskania niestandardowego viewModel.

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

Ogólna klasa typów

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

Chciałem przekazać T.classowi metodę, która korzysta z Generics

Metoda readFile czyta plik .csv określony przez fileName z pełną ścieżką. Mogą istnieć pliki csv o różnej zawartości, dlatego muszę przekazać klasę pliku modelu, aby uzyskać odpowiednie obiekty. Ponieważ to czyta plik csv, chciałem zrobić w ogólny sposób. Z tego czy innego powodu żadne z powyższych rozwiązań nie działało dla mnie. Muszę użyć, Class<? extends T> typeżeby to działało. Używam biblioteki opencsv do parsowania plików 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;
}

W ten sposób wywoływana jest metoda readFile

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

Korzystam z obejścia tego:

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

MyClass myClassInstance = MyClass.class.newInstance();