Module Java.4 – Types
Objectif
Maîtriser tous les types Java : types primitifs, types objets, wrapper classes, et comprendre les conversions entre types pour manipuler les données efficacement.
Théorie
Types primitifs
Java a 8 types primitifs (pas des objets).
Entiers
byte : 8 bits (-128 à 127)
byte b = 127;
byte negatif = -128;
short : 16 bits (-32,768 à 32,767)
short s = 32767;
int : 32 bits (-2^31 à 2^31-1)
int i = 2147483647;
int hexa = 0xFF; // Hexadécimal
int octal = 077; // Octal
int binaire = 0b1010; // Binaire (Java 7+)
long : 64 bits (-2^63 à 2^63-1)
long l = 9223372036854775807L; // L obligatoire
long grand = 1_000_000_000L; // Underscores pour lisibilité
Décimaux
float : 32 bits, simple précision
float f = 3.14f; // f obligatoire
float scientifique = 1.5e3f; // 1500.0
double : 64 bits, double précision
double d = 3.141592653589793;
double scientifique = 1.5e3; // 1500.0
Précision :
- float : ~7 décimales significatives
- double : ~15 décimales significatives
- Pour l'argent, utiliser BigDecimal
Autres
char : 16 bits Unicode
char c = 'A';
char unicode = '\u0041'; // 'A' en Unicode
char tab = '\t';
char newline = '\n';
boolean : true ou false
boolean vrai = true;
boolean faux = false;
// Pas de conversion avec int (contrairement à C)
Types objets (Wrappers)
Chaque type primitif a une classe wrapper correspondante.
Wrapper classes
Byte b = Byte.valueOf((byte) 127);
Short s = Short.valueOf((short) 32767);
Integer i = Integer.valueOf(42);
Long l = Long.valueOf(9223372036854775807L);
Float f = Float.valueOf(3.14f);
Double d = Double.valueOf(3.14159);
Character c = Character.valueOf('A');
Boolean bool = Boolean.valueOf(true);
Auto-boxing et Unboxing
Conversion automatique entre primitifs et wrappers (depuis Java 5).
Auto-boxing : Primitif → Objet
Integer i = 42; // Équivalent à Integer.valueOf(42)
Double d = 3.14; // Équivalent à Double.valueOf(3.14)
Auto-unboxing : Objet → Primitif
Integer i = 42;
int j = i; // Équivalent à i.intValue()
Exemple pratique :
List<Integer> nombres = new ArrayList<>();
nombres.add(10); // Auto-boxing : int → Integer
int premier = nombres.get(0); // Auto-unboxing : Integer → int
Attention aux performances :
// ❌ Lent : beaucoup d'auto-boxing
Integer somme = 0;
for (int i = 0; i < 1000000; i++) {
somme += i; // Auto-boxing à chaque itération
}
// ✅ Rapide : utilise int primitif
int somme = 0;
for (int i = 0; i < 1000000; i++) {
somme += i;
}
Conversions de types
Conversion implicite (widening)
Conversion automatique vers un type plus large.
byte b = 10;
short s = b; // byte → short
int i = s; // short → int
long l = i; // int → long
float f = l; // long → float
double d = f; // float → double
Ordre de widening :
byte → short → int → long → float → double
char → int → long → float → double
Conversion explicite (casting)
Conversion forcée vers un type plus petit.
int i = 300;
byte b = (byte) i; // 44 (troncature, perte de données)
double d = 3.14;
int i = (int) d; // 3 (troncature)
Attention : Perte de données possible.
Conversions String
Vers String :
int i = 42;
String s = String.valueOf(i); // "42"
String s2 = Integer.toString(i); // "42"
String s3 = "" + i; // "42" (concaténation)
Depuis String :
String s = "42";
int i = Integer.parseInt(s); // 42
double d = Double.parseDouble("3.14"); // 3.14
boolean b = Boolean.parseBoolean("true"); // true
Gestion d'erreurs :
try {
int i = Integer.parseInt("abc"); // NumberFormatException
} catch (NumberFormatException e) {
System.out.println("Nombre invalide");
}
Comparaison des types
Primitifs
int a = 5;
int b = 5;
a == b; // true (comparaison de valeurs)
Objets
Integer a = new Integer(5);
Integer b = new Integer(5);
a == b; // false (comparaison de références)
a.equals(b); // true (comparaison de valeurs)
String :
String s1 = "test";
String s2 = "test";
String s3 = new String("test");
s1 == s2; // true (même référence dans le pool)
s1 == s3; // false (références différentes)
s1.equals(s3); // true (même contenu)
Méthodes utiles des wrappers
Integer
Integer i = 42;
i.intValue(); // 42 (primitif)
Integer.parseInt("42"); // 42 (depuis String)
Integer.toString(42); // "42"
Integer.max(10, 20); // 20
Integer.min(10, 20); // 10
Integer.compare(10, 20); // -1 (10 < 20)
Double
Double d = 3.14;
d.doubleValue(); // 3.14 (primitif)
Double.parseDouble("3.14"); // 3.14
Double.isNaN(0.0/0.0); // true
Double.isInfinite(1.0/0.0); // true
Character
Character c = 'A';
Character.isLetter('A'); // true
Character.isDigit('5'); // true
Character.isWhitespace(' '); // true
Character.toUpperCase('a'); // 'A'
Character.toLowerCase('A'); // 'a'
BigDecimal et BigInteger
Pour les très grands nombres ou précision exacte.
BigDecimal : Décimaux avec précision exacte
import java.math.BigDecimal;
BigDecimal prix = new BigDecimal("19.99");
BigDecimal taux = new BigDecimal("1.20");
BigDecimal total = prix.multiply(taux); // 23.988
// Pour l'argent, toujours utiliser BigDecimal
BigInteger : Entiers arbitrairement grands
import java.math.BigInteger;
BigInteger grand = new BigInteger("12345678901234567890");
BigInteger autre = grand.add(BigInteger.ONE);
Exercice
-
Types primitifs
- Testez tous les types primitifs
- Comprenez les limites (min/max)
- Testez les conversions implicites
-
Wrappers
- Utilisez les wrapper classes
- Testez auto-boxing/unboxing
- Comparez les performances
-
Conversions
- Testez les conversions implicites
- Testez les casts explicites
- Convertissez vers/depuis String
-
Comparaisons
- Comparez primitifs avec ==
- Comparez objets avec equals()
- Comprenez les différences
-
Méthodes utiles
- Utilisez les méthodes des wrappers
- Testez parseInt, toString, etc.
- Utilisez Character pour validation
Quiz
-
Quel suffixe pour un long littéral ?
- l
- L
- long
-
Que fait auto-boxing ?
- Convertit objet en primitif
- Convertit primitif en objet automatiquement
- Supprime l'objet
-
Comment convertir String en int ?
- (int) "42"
- Integer.parseInt("42")
- String.toInt("42")
-
Quelle est la différence entre == et equals() pour objets ?
- Aucune différence
- == compare références, equals() compare valeurs
- equals() est plus rapide
-
Pourquoi utiliser BigDecimal pour l'argent ?
- Plus rapide
- Précision exacte (évite erreurs d'arrondi)
- Plus simple
Mini défi
Mission : Créer un système de validation de types
Créez des fonctions qui valident et convertissent les types :
Fonctions à créer :
-
Validation
estNombre(String): Vérifie si c'est un nombre valideestEntier(String): Vérifie si c'est un entierestDecimal(String): Vérifie si c'est un décimal
-
Conversion sécurisée
versInt(String, int defaut): Convertit en int, retourne defaut si échecversDouble(String, double defaut): Convertit en doubleversBoolean(String, boolean defaut): Convertit en boolean
-
Manipulation
arrondir(double valeur, int decimales): Arrondit à N décimalesformaterNombre(double valeur, int decimales): Formate avec séparateurs
-
Tests
- Testez avec différentes valeurs
- Testez les cas limites (null, chaînes vides, valeurs invalides)
- Gèrez les exceptions
Exemple d'utilisation :
int age = versInt("30", 0); // 30
int invalide = versInt("abc", 0); // 0 (defaut)
double prix = versDouble("19.99", 0.0); // 19.99
Critères :
- ✅ Toutes les fonctions créées
- ✅ Gestion des erreurs appropriée
- ✅ Utilisation de try/catch
- ✅ Code bien documenté
- ✅ Tests complets avec différents cas
Objectif : Maîtriser tous les types Java et savoir les valider et convertir correctement.
Validation : Vous pouvez passer au module suivant quand vous maîtrisez tous les types Java et leurs conversions.