Conversion de types en Java : élargissement, rétrécissement et conversions

Ce que signifie la conversion de types

Java est à typage statique : chaque valeur a un type, et le compilateur ne vous laissera pas mélanger silencieusement des types incompatibles. La conversion de types est la manière de convertir une valeur d'un type vers un autre — parfois Java le fait pour vous, et parfois vous devez le demander explicitement.

Il y a deux directions. Passer d'un type plus petit à un type plus grand (un int vers un double) est sûr et se produit automatiquement. Passer d'un type plus grand à un type plus petit (un double vers un int) peut perdre des données, donc Java vous oblige à l'indiquer avec une conversion.

Élargissement : la conversion automatique

Une conversion d'élargissement déplace une valeur vers un type ayant plus de place. Rien ne peut être perdu, donc Java le fait pour vous sans conversion :

public class Main {
    public static void main(String[] args) {
        int count = 7;
        double price = count;   // int -> double, automatique

        System.out.println(price);   // 7.0
    }
}

L'int 7 se glisse dans un double et devient 7.0. L'ordre d'élargissement pour les nombres est byte -> short -> int -> long -> float -> double ; affecter de la gauche vers la droite le long de cette chaîne ne nécessite jamais de conversion. C'est pourquoi mélanger des types dans une opération arithmétique « fonctionne souvent tout seul » — Java élargit d'abord l'opérande le plus petit.

Rétrécissement : la conversion explicite

Dans l'autre sens — une conversion de rétrécissement — des données peuvent être perdues, donc le compilateur refuse à moins que vous ne placiez le type cible entre parenthèses devant la valeur :

public class Main {
    public static void main(String[] args) {
        double pi = 3.9;
        int whole = (int) pi;   // conversion de rétrécissement explicite

        System.out.println(whole);   // 3, pas 4
    }
}

(int) pi est la conversion. Notez ce qu'elle fait : elle tronque vers zéro, en supprimant simplement la partie décimale. 3.9 devient 3, et -3.9 devient -3. Elle n'arrondit pas. Si vous voulez arrondir, c'est un outil différent :

public class Main {
    public static void main(String[] args) {
        double value = 3.9;

        System.out.println((int) value);          // 3  (tronque)
        System.out.println(Math.round(value));    // 4  (arrondit)
    }
}

Oublier qu'une conversion tronque est l'un des bugs les plus fréquents chez les débutants — si votre nombre « arrondi » est toujours trop petit d'une unité, c'est généralement la raison.

Le piège de la division entière

Ce piège attrape tout le monde une fois. Lorsque les deux opérandes sont des int, l'opérateur / effectue une division entière et jette le reste — avant toute affectation à un double :

public class Main {
    public static void main(String[] args) {
        int a = 7;
        int b = 2;

        double wrong = a / b;          // 3.0  - la division est faite d'abord en int !
        double right = (double) a / b; // 3.5  - convertis un opérande d'abord

        System.out.println(wrong);
        System.out.println(right);
    }
}

a / b est 7 / 2, calculé entièrement en arithmétique int, ce qui donne 3. Élargir vers double ensuite ne fait que transformer 3 en 3.0 — le .5 est déjà perdu. Convertir un opérande en double d'abord ((double) a / b) force toute l'expression en virgule flottante, donnant le 3.5 que vous vouliez. Vous n'avez besoin de convertir qu'un seul côté ; Java élargit l'autre pour correspondre.

Quand le rétrécissement dépasse la capacité

Une conversion ne vérifie pas si la valeur tient. Si elle ne tient pas, les bits sont simplement tronqués et vous obtenez un résultat surprenant — aucune erreur, aucun avertissement :

public class Main {
    public static void main(String[] args) {
        int big = 300;
        byte small = (byte) big;   // un byte ne contient que -128..127

        System.out.println(small);   // 44, pas 300
    }
}

300 ne tient pas dans un byte, donc les bits de poids fort sont supprimés et vous obtenez 44. C'est une perte de données « silencieuse » — le programme s'exécute sans problème et donne une mauvaise réponse. Ne rétrécissez que lorsque vous êtes sûr que la valeur tient dans le type plus petit.

Convertir entre nombres et chaînes

Une String est un objet, pas un nombre, donc vous ne pouvez pas la convertir avec (int) — c'est une erreur de compilation. La conversion utilise plutôt des méthodes dédiées :

public class Main {
    public static void main(String[] args) {
        String text = "42";
        int n = Integer.parseInt(text);       // String -> int
        double d = Double.parseDouble("3.14"); // String -> double

        System.out.println(n + 1);   // 43

        String back = String.valueOf(n);       // int -> String
        System.out.println(back + "!");         // 42!
    }
}

Pour passer du texte à un nombre, on utilise Integer.parseInt / Double.parseDouble. Si la chaîne n'est pas un nombre valide (disons "hello"), ces méthodes lèvent une NumberFormatException. Pour passer d'un nombre au texte, utilisez String.valueOf(n) ou concaténez simplement avec "" — car n + "" force l'int à devenir une String. Attention à la différence entre "5" + 1 (qui donne la chaîne "51") et 5 + 1 (qui donne 6) ; le + signifie concaténation dès qu'une String est impliquée.

Convertir des objets

La conversion s'applique aussi aux références d'objets, pas seulement aux primitifs. Vous pouvez convertir une référence vers un type apparenté le long d'une chaîne d'héritage — l'élargissement vers un type parent est automatique, le rétrécissement en sens inverse nécessite une conversion explicite et n'est sûr que si l'objet est réellement de ce type :

Object o = "hello";
String s = (String) o;        // OK : o référence réellement une String
Integer bad = (Integer) o;    // compile, mais lève une ClassCastException à l'exécution

La seconde conversion compile mais explose à l'exécution avec une ClassCastException car l'objet est une String, pas un Integer. Vous rencontrerez cela en détail une fois arrivé à l'héritage et au polymorphisme ; pour l'instant, sachez simplement que la syntaxe (Type) est la même idée appliquée aux objets.

Suivant : if-else

La conversion vous permet de remodeler des valeurs ; l'étape suivante consiste à faire en sorte que votre programme choisisse entre des chemins en fonction de ces valeurs. L'instruction if-else exécute un bloc lorsqu'une condition est vraie et un autre lorsqu'elle est fausse — le fondement de chaque décision que prend votre code. C'est la page suivante.