Cómo evitar el borrado de tipo Java

Question

¿Hay alguna forma de evitar el borrado de tipos y obtener acceso a un parámetro de tipo?

public class Foo<T extends Enum<?> & Bar> { 
    public Foo() { 
     // access the template class here? 
     // i.e. : 
     baz(T.class); // obviously doesn't work 
    } 

    private void baz(Class<T> qux) { 
     // do stuff like 
     T[] constants = qux.getEnumConstants(); 
     ... 
    } 
} 

necesito saber sobre T, y hacer cosas con ella. ¿Es posible, y si es así, cómo se puede hacer sin pasando la clase en el constructor o en cualquier lugar además del parámetro?

EDIT: El principal objetivo de esta pregunta es averiguar si hay ninguna forma práctica alrededor de tipo borrado.

Answer 1

AFACT, no hay ninguna forma práctica todo tipo de borrado porque no se puede pedir algo que el tiempo de ejecución no tiene acceso a. Asumiendo, por supuesto, usted acepta que la subclasificación de clases genéricas para cada enumeración que implemente la interfaz Bar es un trabajo práctico.

enum Test implements Bar { 
    ONE, TWO 
} 

class Foo<T> extends FooAbstract<Test> { 
    public Foo() { 
     ParameterizedType genericSuperclass = 
       (ParameterizedType) getClass().getGenericSuperclass(); 
     baz((Class<T>) genericSuperclass.getActualTypeArguments()[0]); 
    } 

    private void baz(Class<T> qux) { 
     T[] constants = qux.getEnumConstants(); 
     System.out.println(Arrays.toString(constants)); // print [ONE, TWO] 
    } 
} 

interface Bar { 
} 

class FooAbstract<T extends Enum<?> & Bar> { 
} 

Answer 2

Si estás dispuesto/capaz de entregar una ficha de clase al constructor:

public Foo(Class<T> clazz) { 
    baz(clazz); 
} 

private void baz(Class<T> qux) { 
    // ... 
} 

De esta manera, se puede producir objetos de tipo T con Class.newInstance(), el intento de echar a objetos arbitrarios T usando Class.cast(), etc.

¿Qué piensas hacer en baz()?

Answer 3

Como señala pholser en su respuesta, la única forma de lograr esto es pasando el objeto Class que representa el tipo T. Es debido a Type Erasure que algo como T.class no es posible porque T se borra antes del tiempo de ejecución.

Parece resistente a pasar en el objeto Class, pero es la única forma de utilizar el método getEnumConstants(). He aquí un ejemplo que figura auto:

public class Foo<T extends Enum<?> & Bar> { 

    final Class<T> clazz; 

    public Foo(Class<T> clazz) { 

     this.clazz = clazz; 
    } 

    public void baz() { 

     T[] constants = clazz.getEnumConstants(); 

     System.out.println(Arrays.toString(constants)); 
    } 

    public static void main(String[] args) { 

     new Foo<MyEnum>(MyEnum.class).baz(); //prints "[A, B, C, D]" 
    } 
} 

public interface Bar { } 

public enum MyEnum implements Bar { A, B, C, D; } 

Answer 4

Utilice un token de super tipo como lo propuso Neil Gafter y utilizado por bibliotecas como guice para este fin.

Ver http://gafter.blogspot.com/2006/12/super-type-tokens.html para la descripción original y he echado un vistazo a la fuente de guice para la implementación de trabajo de CA radio life.

hay otro q que tiene una respuesta con el ejemplo trabajado en línea aquí How can I pass a Class as parameter and return a generic collection in Java?

Answer 5

En algunos casos se puede utilizar una solución sugerida por Richard Gomes. Al crear instancias de clases anónimas, la información de clase de parámetro de tipo está disponible.

class A<T> 
{ 
    A() 
    { 
     java.lang.reflect.ParameterizedType parameterizedType = (java.lang.reflect.ParameterizedType) (this.getClass().getGenericSuperclass()); 
     System.out.println(parameterizedType.getActualTypeArguments()[0]); 
    } 
} 

public class Example { 
public static void main(String[] args) { 
    A<String> anonymous = new A<String>() {}; // prints java.lang.String 
} 
} 

Tenga en cuenta que varias instancias creadas de esta manera serán de diferentes clases anónimas, y si eso es un problema que puede ser que desee un A_String_Factory clase con una función createnew() basado en el clon para reemplazar las llamadas a nuevo.