1. Conversion implicite (automatique) des types
En Java (comme dans d’autres langages), les variables ont un type strict — si une variable est déclarée comme int, elle ne peut stocker que des entiers, et si c’est un double — uniquement des nombres à virgule flottante. Mais dans les programmes réels, il arrive souvent que l’on doive « déplacer » une valeur d’une variable vers une autre d’un type différent. Par exemple :
- On reçoit un int d’une méthode, mais on veut l’utiliser comme double pour des calculs avec des fractions.
- On stocke le code d’un caractère comme nombre (int), et l’on souhaite obtenir le caractère lui‑même (char).
- On a un résultat de calcul en double, mais on a besoin d’un résultat entier (int), par exemple pour afficher le nombre de pommes entières.
En Java, il existe deux façons principales de convertir les types : implicite (automatique) et explicite (manuelle).
Qu’est-ce que c’est ?
La conversion implicite, c’est lorsque Java convertit elle‑même, « sans votre intervention », une valeur d’un type à un autre si c’est sûr et sans perte de données.
Cela se produit lorsque vous affectez une valeur d’un type plus petit à une variable d’un type plus grand. Par exemple, de int vers double, de char vers int, de float vers double.
Analogie : imaginez que vous avez un verre d’eau (int) et un seau (double). Si vous versez l’eau du verre dans le seau, rien ne se renversera, tout rentrera. Java autorise la conversion automatique dans ces cas‑là.
Exemple : int → double
int apples = 5;
double applesWeight = apples; // int devient automatiquement double
System.out.println(applesWeight); // 5.0
Exemple : char → int
Chaque caractère en Java n’est qu’un nombre de la table Unicode. Par conséquent, la conversion de char en int se fait automatiquement :
char letter = 'A';
int code = letter; // 'A' devient 65 (code du caractère dans Unicode)
System.out.println(code); // 65
Table des conversions implicites
| De | Vers (implicitement) |
|---|---|
|
|
|
|
|
|
|
|
|
|
|
|
Important : La conversion implicite ne fonctionne que dans le sens de « l’élargissement » (du plus petit vers le plus grand).
2. Conversion explicite (manuelle) des types (type casting)
La conversion explicite est requise lorsque vous voulez convertir une valeur d’un type plus grand vers un type plus petit ou entre des types incompatibles. Dans ce cas, Java exige que vous indiquiez explicitement que vous êtes conscient d’une éventuelle perte de données.
Analogie : vous essayez de verser l’eau d’un seau (double) dans un verre (int) — une partie de l’eau peut se renverser, et Java exige que vous disiez : « Oui, je comprends qu’une partie des données peut être perdue ! »
Syntaxe
target_type variable = (target_type) expression;
Exemple : double → int
double price = 12.99;
int roundedPrice = (int) price; // la partie fractionnaire est simplement tronquée !
System.out.println(roundedPrice); // 12
Attention : Il n’y a pas d’arrondi ! On coupe simplement tout ce qui suit le point. Pour arrondir, utilisez Math.round().
Exemple : int → char
int code = 66;
char letter = (char) code; // 66 — c’est le caractère 'B'
System.out.println(letter); // B
Exemple : double → float
double d = 3.1415926535;
float f = (float) d; // une partie de la précision est perdue
System.out.println(f); // 3.1415927 (moins de chiffres après la virgule)
3. Conversion entre nombres et caractères (char et nombres)
Pourquoi est-ce possible ?
En Java, les caractères (char) sont en réalité de simples nombres issus de la table Unicode. On peut donc les convertir librement en int et inversement.
Exemple : char → int
char ch = '\u0416';
int code = ch;
System.out.println(code); // 1046
Exemple : int → char
int code = 8364;
char symbol = (char) code;
System.out.println(symbol); // €
Pratique : affichons l’alphabet
for (int i = 65; i < 65 + 26; i++) {
System.out.print((char) i + " ");
}
// Affichera: A B C D ... Z
4. Conversion entre entiers et nombres à virgule flottante
int → double (implicite)
int count = 10;
double avg = count; // élargissement implicite
System.out.println(avg); // 10.0
double → int (explicite)
double score = 8.75;
int rounded = (int) score;
System.out.println(rounded); // 8
Comment arrondir selon les règles mathématiques ?
Si vous devez non pas simplement « couper » la partie fractionnaire, mais arrondir à l’entier le plus proche, utilisez Math.round() :
double price = 8.75;
int rounded = (int) Math.round(price);
System.out.println(rounded); // 9
5. Que se passe‑t‑il lors d’un « rétrécissement » de type ? Perte de données
Exemple : int → byte
int big = 300;
byte small = (byte) big;
System.out.println(small); // 44 (!)
Pourquoi 44 ? Parce que byte stocke des valeurs de -128 à 127, et si le nombre ne tient pas, il y a « troncature » modulo 256 (reste de la division).
Exemple : double → int
double d = 1e20;
int i = (int) d;
System.out.println(i); // -2147483648 (valeur minimale de int)
Le grand nombre ne tient pas dans l’intervalle de int, et le résultat devient « étrange ».
6. Conversion lors des calculs : types « mixtes »
Exemple : int + double
int a = 3;
double b = 2.5;
double result = a + b; // int devient automatiquement double
System.out.println(result); // 5.5
Exemple : char + int
char ch = 'A'; // 65
int offset = 2;
char next = (char) (ch + offset); // char devient automatiquement int
System.out.println(next); // C
7. Conversion entre nombres et chaînes
Bien que ce ne soit pas exactement un « cast », on doit souvent convertir un nombre en chaîne et inversement.
int → String
int x = 123;
String s = Integer.toString(x);
// ou tout simplement: String s = "" + x;
String → int
String s = "456";
int x = Integer.parseInt(s);
8. Erreurs typiques et nuances
Erreur n° 1 : Perte de la partie fractionnaire lors de double → int. Très souvent, les débutants pensent que (int) 3.99 donnera 4. En réalité, le résultat est 3 : la partie fractionnaire est simplement supprimée. Pour un arrondi correct, utilisez Math.round().
Erreur n° 2 : Le « rétrécissement » implicite ne fonctionne pas. On ne peut pas simplement écrire int x = 300; byte b = x; — le compilateur produira une erreur. Il faut indiquer explicitement (byte) x, mais préparez‑vous à des résultats étranges si le nombre dépasse l’intervalle de byte.
Erreur n° 3 : Conversion entre types incompatibles. On ne peut pas écrire (int) "123" — une chaîne doit être convertie en nombre via Integer.parseInt().
Erreur n° 4 : Problèmes avec char et int. La conversion de int en char ne fonctionne que pour des valeurs qui existent réellement dans Unicode. Si vous passez un grand nombre, le résultat sera un symbole inattendu.
Erreur n° 5 : Types mixtes dans les expressions. Si une expression contient int et double, le résultat sera toujours un double. Cela peut affecter de façon inattendue la logique du programme si vous attendiez un entier.
Erreur n° 6 : L’arrondi n’est pas une conversion de type ! (int) x n’est pas un arrondi, mais une simple troncature de la partie fractionnaire. Pour arrondir, utilisez Math.round().
GO TO FULL VERSION