Invocation De Méthodes Génériques De Java

Je suis des études en Java fonctionnalité générique et je ne suis pas sûr de savoir comment expliquer la troisième ligne dans la suite de main méthode:

public class Example4 {
    public static void main(final String[] args) {
        System.out.println(Util.<String>compare("a", "b"));
        System.out.println(Util.<String>compare(new String(""), new Long(1)));
        System.out.println(Util.compare(new String(""), new Long(1)));
    }
}

class Util {
    public static <T> boolean compare(T t1, T t2) {
        return t1.equals(t2);
    }
}

La première ligne compile, s'exécute et renvoie (comme prévu) false.

La deuxième ligne ne compile pas comme prévu, parce que je suis explicitement mélange String et Long.

La troisième ligne compile, s'exécute, et renvoie false mais je ne suis pas sûr de comprendre comment il arrive à travailler: le compilateur/JVM instancie le type de paramètre T comme Object? (D'ailleurs, y aurait-il un moyen d'obtenir ce type déclaré de T d'exécution?)

Merci.

InformationsquelleAutor Yann-Gaël Guéhéneuc | 2013-04-08

20

Partagée de type héréditaire de String et Long est Object.

Lorsque vous exécutez cette fonction comme Util.<String>compare( le compilateur s'attend à trouver de chaîne de deux entrées, et donne une erreur quand il n'est pas. Toutefois, l'exécution sans <String> résultats dans l'utilisation de la plus proche partagé de type héréditaire - dans ce cas, Object.

Ainsi, lorsque compare accepte t1 et t2, ils ont été rejetés comme Object, et le code s'exécute bien.

Pour obtenir le type réel au moment de l'exécution, vous utilisez la même technique que vous pouvez utiliser avec n'importe quel autre objet: La getClass() qui est héritée de la Object classe.
- Aussi, pour la deuxième partie(de façon à obtenir le type déclaré de T au moment de l'exécution) de la recherche pour "Réifiée Génériques" sur Google. Reportez-vous gafter.blogspot.com/2006/11/reified-generics-for-java.html
- La méthode getClass() appliquée à, disons, t1, sera de retour en Chaîne, car il est le moteur d'exécution de type, n'est-ce pas?
- Tout en faisant plus de recherche, je suis tombé sur cet intéressant billet de Blog: super jetons de type.
- Vous pouvez également utiliser instanceof, mais c'est plus lent. Cependant, à l'intérieur compare les cordes ont été rendus anonymes - la seule façon de les lire, c'est lire à la classe string et les interpréter (au moins autant que je sache).
InformationsquelleAutor

La réponse semble aller au-delà de @Telthien et @newacct réponses. J'étais curieux de "voir" pour moi la différence entre:

System.out.println(Util.<String>compare("a", "b"));

avec explicitement la dactylographie, et l':

System.out.println(Util.compare(new String(""), new Long(1)));

avec typage implicite.

J'ai effectué plusieurs expériences, à l'aide de variations sur ces deux lignes précédentes. Ces expériences montrent que, à court de l'aide de l' anonyme/classe locale truc, le compilateur ne vérifie pas le type lors de la compilation, la génération de bytecode seulement se référer à Object, même dans le cas de la première ligne.

Le morceau de code suivant montre que typecasts peut être effectuée en toute sécurité tout le chemin à Object même dans le cas de la explicitement argument de type <String>.

public final class Example44 {
    public static void main(final String[] args) {
        System.out.println(new Util44<String>().compare("a", "b"));
        System.out.println(new Util44().compare(new String(""), new Long(1)));
    }
}

final class Util44<T> {
    private T aT;
    public boolean compare(T t1, T t2) {
        System.out.println(this.aT);
        //I was expecting the second and third assignments to fail
        //with the first invocation because T is explicitly a String
        //and then to work with the second invocation because I use
        //a raw type and the compiler must infer a common type for T.
        //Actually, all these assignments succeed with both invocation. 
        this.aT = (T) new String("z");
        this.aT = (T) new Long(0);
        this.aT = (T) new Object();
        return t1.equals(t2);
    }
}

Le bytecode de la main méthode de ressembler à:

  //Method descriptor #15 ([Ljava/lang/String;)V
//Stack: 7, Locals: 1
public static void main(java.lang.String[] args);
0  getstatic java.lang.System.out : java.io.PrintStream [16]
3  new ca.polymtl.ptidej.generics.java.Util44 [22]
6  dup
7  invokespecial ca.polymtl.ptidej.generics.java.Util44() [24]
10  ldc <String "a"> [25]
12  ldc <String "b"> [27]
14  invokevirtual ca.polymtl.ptidej.generics.java.Util44.compare(java.lang.Object, java.lang.Object) : boolean [29]
17  invokevirtual java.io.PrintStream.println(boolean) : void [33]
20  getstatic java.lang.System.out : java.io.PrintStream [16]
23  new ca.polymtl.ptidej.generics.java.Util44 [22]
26  dup
27  invokespecial ca.polymtl.ptidej.generics.java.Util44() [24]
30  new java.lang.String [39]
33  dup
34  ldc <String ""> [41]
36  invokespecial java.lang.String(java.lang.String) [43]
39  new java.lang.Long [46]
42  dup
43  lconst_1
44  invokespecial java.lang.Long(long) [48]
47  invokevirtual ca.polymtl.ptidej.generics.java.Util44.compare(java.lang.Object, java.lang.Object) : boolean [29]
50  invokevirtual java.io.PrintStream.println(boolean) : void [33]
53  return
Line numbers:
[pc: 0, line: 24]
[pc: 20, line: 25]
[pc: 53, line: 26]
Local variable table:
[pc: 0, pc: 54] local: args index: 0 type: java.lang.String[]

Il fait réellement sens que tous les appels sont toujours à des méthodes avec Object comme paramètre formel types, comme expliqué dans une autre question/réponse. Pour conlude, le compilateur utilise toujours Object pour le bytecode généré, pas grave si il est explicitement argument de type (première ligne) ou implicite de l'argument type, mais que les objets pourraient avoir une super-classe commune différente de Object.

Juste à noter ici, même si vous vous liez à l'; le phénomène est appelé "type d'effacement".
Ouais. Fondamentalement, Java implémente les génériques comme de derrière-le-scènes typecasting. Par exemple, un ArrayList<String> en interne considère chaque élément à une Object, mais automatiquement il jette en arrière pour String lorsque vous l'utilisez.

InformationsquelleAutor Yann-Gaël Guéhéneuc

2

Oui, Object est un choix pour T qui permet de le compiler. Sur le plan conceptuel, le compilateur déduit un type pour T. Ce qu'on en déduit en particulier n'a pas d'importance-tant qu'il peut en déduire que un certain type de travail pour T, alors qu'il compile. Il n'a pas d'importance ce que le type inféré est, puisqu'il n'a pas d'effet sur le code compilé.

InformationsquelleAutor newacct

Vous devez vous connecter pour publier un commentaire.