Génériques Java

Question

Je voudrais implémenter une méthode qui prend un Object comme argument, le convertit en un type arbitraire, et si cela échoue, retourne null. Voici ce que j'ai jusqu'à présent:

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

Malheureusement, l'exception de fonte de classe est jamais jeté/pris dans le corps de la fonction staticCast(). Il semble que le compilateur Java génère la fonction String staticCast(Object arg) dans laquelle vous avez une ligne String result = (String) arg; même si je dis explicitement que le type de modèle doit être MyClass. De l'aide? Merci.

Answer 1

Parce que l'information de type générique est effacé lors de l'exécution, la manière standard de caster un type générique est un objet 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; 
} 

Ensuite, appelez comme ceci:

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

Answer 2

Vous ne pouvez pas faire ce que vous voulez ... du moins pas de cette façon. Le compilateur a supprimé toutes les informations afin que vous finissiez avec (T) étant Object dans la distribution - et cela fonctionne.

Le problème est que plus tard vous faites l'objet MyClass = (String); et ce n'est pas autorisé.

Vous avez contourné la vérification des compilateurs et l'avez fait échouer lors de l'exécution.

Alors, qu'est-ce que vous essayez de faire exactement? Si vous nous dites pourquoi vous voulez faire cela, nous pouvons probablement vous dire la façon Java de le faire.

Compte tenu de votre commentaire, vous pouvez essayer quelque chose comme:

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

Ne confondez pas Java génériques pour les modèles C++. Il va seulement être une méthode staticCast qui est appelée avec différents effacement de type, pas un pour chaque T.

Ne pas utiliser Génériques du tout, je l'écrire de cette façon:

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

ou le vol d'un autre répondre, en utilisant des génériques:

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

Vous voulez dire Class<T>.cast(Object obj)?

Quelque chose comme:

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

devrait faire à peu près ce que vous voulez. Sachez que c'est assez malodorant cependant et est probablement un signe de mauvaise conception.

Answer 5

Je suis d'accord avec Ben, cependant, je préfère la notation suivante:

MyClass.class.cast(obj);