Programmation Orientée Objet avec Java

04 : Éléments de Base - Transtypage, Types Référence et Chaînes de Caractères

Transtypage (Casting)

Définition :

Le transtypage (casting) est une conversion de type explicite effectuée sous la responsabilité du programmeur.

Syntaxe :

(Type_de_destination) Valeur_à_convertir

Exemples détaillés :

int i = 17;
byte b = 4; // Conversion implicite : littéral int -> byte
// b = i; // ERREUR à la compilation - conversion restrictive nécessite un cast
b = (byte)i; // Conversion explicite (int -> byte)

float f = 23.86f;
i = (int)f; // Valeur tronquée (i == 23)

Cas courants de transtypage :

// Conversion avec perte de précision
double d = 9.99;
int entier = (int)d; // entier = 9 (troncature)

// Conversion entre entiers de tailles différentes
long grand = 100000L;
short petit = (short)grand; // Risque de débordement

// Conversion caractère ↔ entier
char c = 'A';
int code = (int)c; // code = 65
char suivant = (char)(c + 1); // suivant = 'B'

Attention : Le transtypage peut entraîner :

Une perte de précision (flottant → entier)
Un débordement (entier trop grand pour le type cible)
Des valeurs inattendues (négatives pour des positifs)

Types "Référence"

Définition :

En plus des huit types primitifs, Java définit les types référence qui incluent :

Les classes
Les tableaux

Caractéristiques des types référence :

Types généralement composites (représentant des valeurs multiples)
Également appelés types non-primitifs
La variable contient une référence (adresse mémoire) vers l'objet
L'objet réel est stocké ailleurs en mémoire

Représentation en mémoire :

Type primitif :

int age = 25;

Mémoire : age → [25] (la variable contient directement la valeur)

Type référence :

String nom = "Dupont";

Mémoire : nom → [référence] → "Dupont" (la variable contient une adresse)

Exemples de types référence :

// Classes prédéfinies
String nom = "Jean";
Integer age = 25; // Classe wrapper pour int

// Tableaux
int[] nombres = {1, 2, 3};
String[] noms = {"Alice", "Bob"};

// Classes personnalisées
Personne personne = new Personne();

Chaînes de Caractères (String)

Caractéristiques :

Ne font pas partie des types primitifs
Font partie des types référence (objets de la classe String)
Syntaxe simplifiée pour les valeurs littérales

Syntaxe des littéraux String :

// Texte entre guillemets
String message = "Ceci est une chaîne de caractères";

// Séquences d'échappement
String citation = "Le caractère \" se nomme 'guillemet'";

// Concaténation avec l'opérateur +
String phrase = "La conca" + "ténation peut s'étendre " +
"sur plusieurs lignes";

Important : Ne pas confondre :

'A' : caractère (type char)
"A" : chaîne de caractères (type String)
65 : nombre entier (type int)

Opérations courantes sur les String :

String s1 = "Bonjour";
String s2 = "Monde";

// Concaténation
String message = s1 + " " + s2; // "Bonjour Monde"

// Longueur
int longueur = s1.length(); // 7

// Conversion en majuscules/minuscules
String maj = s1.toUpperCase(); // "BONJOUR"
String min = s1.toLowerCase(); // "bonjour"

Conversions Types Primitifs ↔ String

Méthodes de conversion :

Type primitif	Classe Wrapper	Conversion vers String	Conversion depuis String
`byte`	`Byte`	`Byte.toString(byte b)`	`Byte.parseByte(String s)`
`short`	`Short`	`Short.toString(short s)`	`Short.parseShort(String s)`
`int`	`Integer`	`Integer.toString(int i)`	`Integer.parseInt(String s)`
`long`	`Long`	`Long.toString(long l)`	`Long.parseLong(String s)`
`float`	`Float`	`Float.toString(float f)`	`Float.parseFloat(String s)`
`double`	`Double`	`Double.toString(double d)`	`Double.parseDouble(String s)`

Méthode universelle de conversion vers String :

String.valueOf(valeur); // Fonctionne avec tous les types primitifs

Exemples détaillés de conversions :

int i; // Variable de type int
float f; // Variable de type float
double d; // Variable de type double
String s; // Variable de type String

// Conversions String → types primitifs
s = "412";
i = Integer.parseInt(s); // Conversion String -> int

s = "1.234";
d = Double.parseDouble(s); // Conversion String -> double

// Conversions types primitifs → String
f = 123.8F;
s = Float.toString(f); // Conversion float -> String
s = String.valueOf(f); // Conversion float -> String (méthode alternative)

Exemples complémentaires :

// Conversion avec gestion d'erreur
try {
    int nombre = Integer.parseInt("123");
    System.out.println("Nombre: " + nombre);
} catch (NumberFormatException e) {
    System.out.println("Chaîne invalide");
}

// Conversion multiple
double d = 45.67;
String s = Double.toString(d); // "45.67"
float f = Float.parseFloat(s); // 45.67f

Exemples Pratiques Complets

Exemple 1 : Application des conversions

public class ConversionsPratiques {
    public static void main(String[] args) {
        // Données initiales
        int age = 25;
        double salaire = 2500.75;
        String nom = "Pierre";

        // Conversions vers String
        String ageStr = String.valueOf(age);
        String salaireStr = Double.toString(salaire);

        // Affichage formaté
        System.out.println(nom + " a " + ageStr + " ans et gagne " + salaireStr);

        // Conversion depuis String
        String input = "30";
        int nouvelAge = Integer.parseInt(input);
        System.out.println("Dans 5 ans: " + (nouvelAge + 5));
    }
}

Exemple 2 : Gestion des erreurs de conversion

public class GestionConversions {
    public static void main(String[] args) {
        String[] inputs = {"123", "45.67", "abc", "1000"};

        for (String input : inputs) {
            try {
                int valeur = Integer.parseInt(input);
                System.out.println(input + " → " + valeur);
            } catch (NumberFormatException e) {
                System.out.println(input + " : conversion impossible");
            }
        }
    }
}

Questions de Cours

Question 1: Transtypage et perte d'information

Quel sera le résultat des opérations de transtypage suivantes et pourquoi?

double d = 15.99;
int i = (int) d;
long l = 1000000;
short s = (short) l;
float f = 123.456f;
int j = (int) f;

Réponse :

i = 15 (troncature de la partie décimale)
s = 16960 (débordement : 1000000 % 65536 = 16960)
j = 123 (troncature de la partie décimale)

Explication : Le transtypage des flottants vers les entiers tronque la partie décimale. Le transtypage d'un long vers un short peut causer un débordement si la valeur dépasse la capacité du type cible.

Question 2: Types référence vs types primitifs

Quelle est la différence fondamentale entre une variable de type primitif et une variable de type référence en termes de stockage en mémoire?

Réponse :

Type primitif : La variable contient directement la valeur.

Type référence : La variable contient une adresse mémoire (référence) vers l'objet qui contient la valeur.

// Type primitif
int age = 25; // age → [25]

// Type référence
String nom = "Dupont"; // nom → [référence] → "Dupont"

Question 3: Chaînes de caractères et séquences d'échappement

Qu'affichera cette instruction et pourquoi?

System.out.println("Chemin: C:\\Users\\Nom\\Documents\nFichier: \"test.txt\"");

Réponse :

Chemin: C:\Users\Nom\Documents
Fichier: "test.txt"

Explication des séquences d'échappement :

\\ → backslash littéral
\n → saut de ligne
\" → guillemet littéral

Question 4: Conversions String vers types numériques

Quelles seront les valeurs des variables après exécution de ce code?

String s1 = "123";
String s2 = "45.67";
String s3 = "true";

int a = Integer.parseInt(s1);
double b = Double.parseDouble(s2);
boolean c = Boolean.parseBoolean(s3);

Réponse :

a = 123
b = 45.67
c = true

Note : Boolean.parseBoolean() est insensible à la casse et reconnaît "true" (quelque soit la casse) comme vrai, toute autre valeur comme faux.

Question 5: Différences entre les littéraux

Quelle est la différence entre '5', "5" et 5 en Java?

Réponse :

'5' : caractère (type char), valeur Unicode 53
"5" : chaîne de caractères (type String), objet contenant un caractère
5 : nombre entier (type int), valeur numérique 5

Conséquences :

char c = '5'; // OK
String s = "5"; // OK
int i = 5; // OK
// int j = "5"; // ERREUR - types incompatibles

Question 6: Méthodes de conversion alternatives

Quelle est la différence entre Integer.toString(123) et String.valueOf(123)?

Réponse :

Les deux méthodes produisent le même résultat : la chaîne "123".

Différences :

Integer.toString(123) : méthode spécifique à la classe Integer
String.valueOf(123) : méthode générale de la classe String qui fonctionne avec tous les types

String.valueOf() est plus polyvalente car elle accepte tous les types primitifs et les objets.

Question 7: Gestion des erreurs de conversion

Que se passe-t-il si on essaie de convertir la chaîne "12a3" en entier avec Integer.parseInt()? Comment gérer cette situation?

Réponse :

Une NumberFormatException est levée car "12a3" n'est pas un nombre valide.

Solution : Utiliser un bloc try-catch pour gérer l'exception :

try {
    int valeur = Integer.parseInt("12a3");
    System.out.println(valeur);
} catch (NumberFormatException e) {
    System.out.println("Chaîne non numérique");
}

Question 8: Comportement des types référence

Qu'affichera ce programme et pourquoi?

String s1 = "Hello";
String s2 = s1;
s2 = s2 + " World";
System.out.println("s1 = " + s1);
System.out.println("s2 = " + s2);

Réponse :

s1 = Hello
s2 = Hello World

Explication :

Les objets String sont immuables en Java. Lorsqu'on modifie un String, on crée en réalité un nouvel objet. Ainsi :

s2 = s1 fait référence au même objet "Hello"
s2 = s2 + " World" crée un nouvel objet "Hello World"
s1 continue de référencer l'objet original "Hello"

Question 9: Conversions implicites dans les expressions

Quelles conversions automatiques seront effectuées dans cette expression?

String resultat = "Valeur: " + 10 + 5.5 + 'A' + true;

Réponse :

L'expression sera évaluée de gauche à droite :

"Valeur: " + 10 → "Valeur: 10" (int → String)
"Valeur: 10" + 5.5 → "Valeur: 105.5" (double → String)
"Valeur: 105.5" + 'A' → "Valeur: 105.5A" (char → String)
"Valeur: 105.5A" + true → "Valeur: 105.5Atrue" (boolean → String)

Résultat final : "Valeur: 105.5Atrue"

Question 10: Choix de la méthode de conversion

Dans quels cas préférer Integer.toString() plutôt que la concaténation avec + pour convertir un int en String?

Réponse :

On préfère Integer.toString() ou String.valueOf() dans les cas suivants :

Performance : Dans les boucles intensives, pour éviter la création multiple d'objets String intermédiaires
Clarté : Quand l'intention est explicitement une conversion de type
Formatage : Quand on a besoin de formats spécifiques (base différente)

// Avec concaténation (simple mais moins efficace en boucle)
String s1 = "Nombre: " + 42;

// Avec conversion explicite (plus clair pour l'intention)
String s2 = "Nombre: " + Integer.toString(42);

// Avec format spécifique
String s3 = Integer.toHexString(255); // "ff"

Bonnes Pratiques

Utilisez le transtypage uniquement lorsque nécessaire et soyez conscient des pertes possibles
Préférez les conversions implicites lorsque c'est possible
Utilisez String.valueOf() pour des conversions vers String polyvalentes
Toujours gérer les NumberFormatException lors des conversions depuis String
Utilisez les classes Wrapper pour les conversions entre types primitifs et String
Soyez conscient de l'immuabilité des objets String

Résumé du Chapitre

Le transtypage permet des conversions explicites entre types, mais peut entraîner une perte d'information
Les types référence (classes, tableaux) stockent des références vers les objets en mémoire
Les chaînes de caractères (String) sont des types référence avec une syntaxe littérale simplifiée
Les conversions entre types primitifs et String utilisent les classes Wrapper
Les méthodes parseXxx() convertissent String → type primitif
Les méthodes toString() et valueOf() convertissent type primitif → String
Il est essentiel de gérer les exceptions lors des conversions depuis String

Précédent Transtypage et Références Suivant

★ ★ ★ ★ ★

Aucune note. Soyez le premier à attribuer une note !

Ajouter un commentaire

Nom

E-mail

Site Internet

Anti-spam