Conversion de types en Java

La conversion de types consiste à transformer une valeur d'un type vers un autre. En Java, cela se décline en deux formes : les conversions élargies, qui se produisent automatiquement et ne perdent jamais d'information, et les conversions rétrécies, qui nécessitent un cast explicite et peuvent entraîner une perte de données.

Conversion élargie (implicite)

Une conversion élargie déplace une valeur vers un type plus grand. Le compilateur la gère automatiquement — aucune syntaxe n'est nécessaire :

int i = 100;
long l = i;        // int → long (widening)
double d = l;      // long → double (widening)

System.out.println(i);   // 100
System.out.println(l);   // 100
System.out.println(d);   // 100.0

L'ordre standard des conversions élargies est :

byte → short → int → long → float → double
              char ↗

(char s'élargit vers int et au-delà, mais pas vers short ni byte.)

La conversion élargie ne perd jamais de plage — un long tient toujours dans la plage d'un double, même si double ne peut pas représenter exactement chaque valeur long. Attention à cet écart de représentation exacte aux valeurs extrêmes.

Cast rétréci (explicite)

Une conversion rétrécie déplace une valeur vers un type plus petit. Java refuse de le faire implicitement car des données peuvent être perdues. Vous devez l'indiquer explicitement avec (targetType) :

double d = 9.99;
int i = (int) d;   // explicit narrowing cast

System.out.println(i);   // 9 — the fractional part is dropped

Le cast tronque vers zéro — il n'arrondit pas.

Pour les entiers, un cast conserve uniquement les bits de poids faible :

int big = 130;
byte b = (byte) big;
System.out.println(b);   // -126 — overflow wraps around

byte est sur 8 bits, plage -128…127. Les bits de 130 (10000010) s'interprètent comme -126 en complément à deux.

Un cast courant : division entière vers un nombre réel

L'arithmétique purement entière utilise la division entière — 5 / 2 == 2, et non 2.5. Pour obtenir un résultat réel, castez au moins un opérande avant la division :

int total = 5;
int count = 2;

double avgWrong = total / count;          // 2.0 — division is still integer
double avgRight = (double) total / count; // 2.5 — total widened first

C'est la raison la plus courante d'utiliser un cast.

Casts de références

La syntaxe (Type) fonctionne également sur les objets — mais là, c'est une vérification à l'exécution, pas une conversion. Caster une référence revient essentiellement à dire « faites-moi confiance, cet objet est de type X » :

Object o = "Hello";
String s = (String) o;            // OK at runtime
System.out.println(s.length());   // 5

Object n = Integer.valueOf(7);
String bad = (String) n;          // throws ClassCastException at runtime

Pour caster une référence en toute sécurité, vérifiez d'abord le type avec instanceof :

Object o = "Hello";
if (o instanceof String) {
    String s = (String) o;        // guaranteed safe
    System.out.println(s.length());
}

Le pattern matching pour instanceof (Java moderne) permet de faire la vérification et le cast en une seule étape. Les casts de références sont traités en détail dans POO et Polymorphisme.

Un exemple complet

Quand le compilateur « aide » — et quand il n'aide pas

Un cas subtil à surveiller : l'arithmétique sur byte, short ou char est automatiquement promue en int avant l'opération. Le résultat est un int :

byte a = 10;
byte b = 20;
// byte sum = a + b;       // compile error: result is int
byte sum = (byte) (a + b);  // explicit cast needed

Cela surprend tout le monde la première fois. Soit vous stockez le résultat dans un int, soit vous recastez.

Règles pratiques

• Élargissez librement — aucun cast nécessaire, aucune perte.
• Rétrécissez avec un cast et une vérification — assurez-vous que la valeur tient vraiment.
• Pour la division en nombre réel d'entiers, castez un opérande en double.
• Pour les calculs monétaires, n'utilisez pas double du tout — utilisez BigDecimal pour éviter les erreurs d'arrondi en virgule flottante binaire.

La suite

Les opérateurs Java — la présentation complète de tous les opérateurs du langage.

Pratique