Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / Java

Inférence de types et boxing dans les méthodes génériques

Java déduit les arguments de type à partir des arguments d’appel et, selon le contexte, du type attendu du résultat. Le boxing permet de passer un `int` sous forme d’`Integer`, sans utiliser de type primitif comme argument de type.

Version : Java SE 21

Syntaxe

static <T> T echo(T value) { return value; }
static <T extends Comparable<? super T>> T min(T a, T b) { return a.compareTo(b) <= 0 ? a : b; }
static <T> void swap(T[] values, int i, int j) { T temp = values[i]; values[i] = values[j]; values[j] = temp; }

String echoString = echo("Java");
Integer minInteger = min(7, 3);
String explicit = Main.<String>echo("Java");

En Java SE 21, une méthode générique déclare ses propres paramètres de type avant son type de retour. Dans static <T> T echo(T value), <T> déclare le paramètre et le T qui suit est le type de retour. Pour echo("Java"), le compilateur infère String. Le type cible peut aussi guider l’inférence : dans String text = echo(null);, l’affectation fournit une information de type que null seul ne donne pas. Main.<String>echo("Java") indique le type explicitement.

echo et swap ne déclarent pas de borne explicite : Object est la borne supérieure implicite de T. swap échange deux éléments dans le tableau d’origine sans les comparer. Cela fonctionne avec String[], mais pas avec int[] : Java ne transforme pas automatiquement un tableau int[] entier en Integer[] par boxing.

min utilise <T extends Comparable<? super T>> : les valeurs de type T doivent pouvoir être comparées entre elles avec compareTo, qui peut accepter T ou un supertype de T. La méthode renvoie la plus petite valeur, ou la première en cas d’égalité. Dans min(7, 3), le compilateur infère Integer et les arguments int sont convertis par boxing. int ne peut pas être un argument de type. int minimum = minInteger; effectue l’unboxing du résultat ; l’unboxing de null déclenche une NullPointerException.

Pour résoudre une surcharge, le compilateur cherche d’abord les méthodes applicables sans boxing ni unboxing. Il n’autorise ces conversions que si aucune méthode ne convient. L’invocation à nombre variable d’arguments n’est envisagée qu’en dernier. Ajouter une surcharge min(int, int) changerait donc la méthode appelée par min(7, 3).

Exemples

public class Main {
    static <T> T echo(T value) {
        return value;
    }

    static <T extends Comparable<? super T>> T min(T a, T b) {
        return a.compareTo(b) <= 0 ? a : b;
    }

    static <T> void swap(T[] values, int i, int j) {
        T temp = values[i];
        values[i] = values[j];
        values[j] = temp;
    }

    public static void main(String[] args) {
        String echoString = echo("Java");
        Integer minInteger = min(7, 3);
        int minimum = minInteger;

        String[] words = {"left", "right"};
        swap(words, 0, 1);

        System.out.println(echoString);
        System.out.println(minimum);
        System.out.println(words[0] + ", " + words[1]);
    }
}

Résultat

Java
3
right, left

La première ligne montre le résultat de `echo`, la deuxième le minimum après unboxing et la troisième l’ordre des éléments du même tableau après `swap`.

Leçons associées

  • Java · Leçon 15 · Avancé · Version : 2

Sources