0Pricing
Java Academy · Leçon

Conversions avec élargissement et réduction

Découvrez les conversions automatiques avec élargissement et apprenez à effectuer des conversions explicites avec réduction en toute sécurité.

Conversions avec élargissement et réduction est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

Conversions de types en Java

Java permet de convertir des valeurs entre types compatibles. Il existe deux directions :

  • Élargissement — conversion vers un type plus grand (sûre et automatique)
  • Rétrécissement — conversion vers un type plus petit (risquée et nécessitant une conversion explicite)

Conversion par élargissement

L'élargissement se produit automatiquement lorsque vous affectez une valeur à un type compatible plus grand. Aucune donnée n'est perdue, car le type cible peut représenter toutes les valeurs du type source.

Ordre d'élargissement : byte → short → int → long → float → double

byte b = 42;
short s = b;    // byte → short (widening)
int i = s;      // short → int (widening)
long l = i;     // int → long (widening)
float f = l;    // long → float (widening)
double d = f;   // float → double (widening)

System.out.println(d); // 42.0

Conversion par rétrécissement

Le rétrécissement doit être effectué explicitement avec l'opérateur de conversion (type). La valeur peut être tronquée ou altérée si elle ne tient pas dans le type cible.

double price = 99.99;
int wholePart = (int) price; // narrows — decimal truncated
System.out.println(wholePart); // 99 (not rounded!)

long bigNum = 130L;
byte small = (byte) bigNum;  // 130 overflows byte (max 127)
System.out.println(small);   // -126 (unexpected!)

Dépassement lors d'un rétrécissement

Lorsqu'une valeur dépasse les limites pendant un rétrécissement, Java la fait revenir au début selon l'arithmétique modulaire : aucune exception n'est levée. Vous devez gérer ce cas manuellement.

int million = 1_000_000;
byte narrowed = (byte) million;
System.out.println(narrowed); // 64 (wraps around)

// Safe narrowing: check bounds first
if (million >= Byte.MIN_VALUE && million <= Byte.MAX_VALUE) {
    byte safe = (byte) million;
} else {
    System.out.println("Value doesn't fit in byte!");
}

Conversions entre char et int

char est un entier non signé sur 16 bits représentant un point de code Unicode. Il est automatiquement élargi en int, mais la conversion inverse de int vers char doit être explicite.

char letter = 'A';
int code = letter;          // widening: char → int
System.out.println(code);   // 65

int nextCode = code + 1;
char nextLetter = (char) nextCode; // narrowing: int → char
System.out.println(nextLetter);    // B

// Useful for Caesar cipher shifts
char shifted = (char) ('a' + 3);
System.out.println(shifted); // d

Troncature d'un nombre à virgule flottante en entier

La conversion d'un nombre à virgule flottante en entier le tronque vers zéro : elle ne l'arrondit pas. Utilisez Math.round() si vous avez besoin d'un arrondi.

double pos = 3.9;
double neg = -3.9;

System.out.println((int) pos);         // 3 (not 4)
System.out.println((int) neg);         // -3 (not -4)
System.out.println(Math.round(pos));   // 4
System.out.println(Math.round(neg));   // -4

Conversions de String en nombres

Analyser une String pour obtenir un nombre utilise des méthodes de classes enveloppes, et non une conversion de type. Le passage d’une chaîne non numérique lève NumberFormatException.

String input = "42";
int parsed = Integer.parseInt(input);
double parsedD = Double.parseDouble("3.14");

System.out.println(parsed + 1);  // 43
System.out.println(parsedD);     // 3.14

try {
    int bad = Integer.parseInt("abc");
} catch (NumberFormatException e) {
    System.out.println("Not a valid number!");
}

Conversions de nombres en String

Convertir un nombre en String peut se faire avec String.valueOf(), Integer.toString() ou par concaténation avec "".

int score = 95;
String s1 = String.valueOf(score);    // "95"
String s2 = Integer.toString(score);  // "95"
String s3 = score + "";              // "95" (concat trick)

System.out.println(s1.getClass().getSimpleName()); // String

// Converting to different bases
System.out.println(Integer.toBinaryString(42)); // 101010
System.out.println(Integer.toHexString(255));   // ff

Promotion dans les expressions

Dans les expressions arithmétiques, Java promeut automatiquement les opérandes :

  • byte, short, char → promus en int avant l’opération
  • Si l’un des opérandes est de type long, le résultat est de type long
  • Si l’un des opérandes est de type float ou double, le résultat utilise le type le plus large
byte x = 10;
byte y = 20;
// byte z = x + y; // compile error! sum is promoted to int
int z = x + y;      // correct

long a = 100L;
float b = 2.5f;
double result = a * b; // long * float → double
System.out.println(result); // 250.0

Opérateurs d’affectation composée

Les opérateurs composés comme +=, -= et *= incluent une conversion implicite vers un type plus étroit. Cela vous permet d’écrire du code concis avec des variables de type byte et short.

byte count = 100;
// count = count + 1; // compile error — int result needs cast
count += 1;           // OK — compound op casts automatically
System.out.println(count); // 101

short total = 1000;
total *= 2;  // implicit narrow cast included
System.out.println(total); // 2000

En pratique&nbsp;: analyse sûre d’un entier

Voici un modèle courant : analyser l’entrée de l’utilisateur en toute sécurité, vérifier la plage de valeurs, puis la convertir vers le type exact requis.

public static byte parseAsByte(String input) {
    int value = Integer.parseInt(input); // can throw NumberFormatException
    if (value < Byte.MIN_VALUE || value > Byte.MAX_VALUE) {
        throw new IllegalArgumentException(
            "Value " + value + " out of byte range");
    }
    return (byte) value;
}

// Usage
System.out.println(parseAsByte("100")); // 100
System.out.println(parseAsByte("200")); // IllegalArgumentException

Vérification rapide

Quelle est la sortie du code suivant ?

double d = -7.8;
int i = (int) d;
System.out.println(i);

Récapitulatif&nbsp;: élargissement et réduction

Points essentiels :

  • L’élargissement est automatique et sûr : byte→short→int→long→float→double
  • La réduction nécessite une conversion explicite et peut entraîner une perte de données ou un dépassement de capacité
  • char s’élargit en int ; int peut être reconverti en char avec une conversion explicite
  • La conversion d’un nombre à virgule flottante en int tronque vers zéro, sans arrondir
  • Utilisez Integer.parseInt/Double.parseDouble pour convertir des String en nombres
  • Les opérateurs composés (+=, *=) incluent des conversions implicites vers un type plus étroit

Questions Fréquemment Posées

La leçon « Conversions avec élargissement et réduction » est-elle gratuite ?

Oui — le texte complet de « Conversions avec élargissement et réduction » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Conversions avec élargissement et réduction » ?

Découvrez les conversions automatiques avec élargissement et apprenez à effectuer des conversions explicites avec réduction en toute sécurité. Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Conversions avec élargissement et réduction » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Types primitifs et types de référence
  2. Conversions avec élargissement et réduction
  3. L’opérateur instanceof
  4. La conversion de types en pratique
← Retour à Java Academy