Java generics

Question

Me gustaría implementar un método que toma un Object como argumento, lo arroja a un tipo arbitrario, y si eso falla, devuelve null. Esto es lo que tengo hasta ahora:

public static void main(String[] args) { 
    MyClass a, b; 
    a = Main.<MyClass>staticCast(new String("B")); 
} 

public static class MyClass { 
} 

public static <T> T staticCast(Object arg) { 
    try { 
     if (arg == null) return null; 
     T result = (T) arg; 
     return result; 
    } catch (Throwable e) { 
     return null; 
    } 
} 

Por desgracia, la excepción de difusión clase no es lanzada/atrapado en el cuerpo de la función staticCast(). Parece que el compilador de Java genera la función String staticCast(Object arg) en la que tiene una línea String result = (String) arg; aunque explícitamente digo que el tipo de plantilla debe ser MyClass. ¿Alguna ayuda? Gracias.

Answer 1

Dado que la información de tipo genérico se borra en tiempo de ejecución, la forma estándar para echar a un tipo genérico es con un objeto Class:

public static <T> T staticCast(Object arg, Class<T> clazz) { 
    if (arg == null) return null; 
    if (!clazz.isInstance(arg)) 
     return null; 
    T result = clazz.cast(arg); 
    return result; 
} 

A continuación, llame así:

a = Main.staticCast("B", MyClass.class); 

Answer 2

No puede hacer lo que quiera ... al menos no de esta manera. El compilador eliminó toda la información, por lo que terminas con (T) como Objeto en el elenco, y eso funciona.

El problema es que más adelante está haciendo el objeto MyClass = (String); y eso no está permitido.

Ha omitido la comprobación de los compiladores y ha fallado en el tiempo de ejecución.

Entonces, ¿qué es exactamente lo que estás tratando de hacer? Si nos dice por qué quiere hacer esto, probablemente podamos decirle la forma Java de hacerlo.

Dada su comentario podría intentar algo como:

public class Main 
{ 
    public static void main(String[] args) 
    { 
     String a; 
     MyClass b; 
     a = staticCast(new String("B"), String.class); 
     b = staticCast(new String("B"), MyClass.class); 
     System.out.println(a); 
    } 

    public static class MyClass 
    { 
    } 

    public static <T> T staticCast(Object arg, final Class clazz) 
    { 
     // edit - oops forgot to deal with null... 
     if(arg == null) 
     { 
      return (null); 
     } 

     // the call to Class.cast, as mmeyer did, might be better... probably is better... 
     if(arg.getClass() != clazz) 
     { 
      // Given your answer to Ben S... 
      return (null); 

      // throw new ClassCastException("cannot cast a " + arg.getClass() + " to a " + clazz); 
     } 

     return ((T)arg); 
    } 
} 

Answer 3

No se debe confundir genéricos de Java para las plantillas de C++. No sólo va a ser un método staticCast que se llama con diferentes borrado tipo, no uno para cada T.

No utilizar medicamentos genéricos en absoluto, me gustaría escribir de esta manera:

public static void main(String[] args) { 
    MyClass a, b; 
    a = (MyClass)Main.staticCast(new String("B"), MyClass.class); 
} 

public static class MyClass { 
} 

public static staticCast(Object arg, Class class) { 
     if (arg != null && class.isAssignableFrom(arg)) 
      return arg; 
     return null; 
} 

o el robo de otro contesta, el uso de los genéricos:

public static <T> T staticCast(Object arg, Class<T> class) { 
     if (arg != null && class.isAssignableFrom(arg)) 
     { 
      T result = class.cast(arg); 
      return result; 
     } 
     return null; 
} 

Answer 4

¿Quieres decir como Class<T>.cast(Object obj)?

Algo así como:

Class.forName("YourClass").cast(obj); 

deberían hacer más o menos lo que quiere.

Tenga en cuenta que esto es bastante desagradable y es probable que sea un signo de diseño deficiente.

Answer 5

Estoy de acuerdo con Ben, sin embargo, prefiero la siguiente notación:

MyClass.class.cast(obj);