2.1.1 – Types primitifs

Les types primitifs sont les types de données de base en Java. Ils représentent des valeurs simples comme des nombres, des caractères ou des booléens. Java possède huit types primitifs, chacun ayant une taille fixe et une plage de valeurs spécifique.

📊 Les huit types primitifs de Java

🔢 Types entiers (byte, short, int, long)

Les types entiers permettent de stocker des nombres entiers (positifs, négatifs ou zéro) :

byte

Le type byte est le plus petit type entier. Il est utile pour économiser de la mémoire quand vous savez que les valeurs seront petites :

Exemples d'utilisation de byte :

byte age = 25;
byte temperature = -10;
byte score = 100;  // ✅ Correct (100 est dans la plage -128 à 127)

byte tropGrand = 200;  // ❌ ERREUR : 200 dépasse 127

short

Le type short peut stocker des entiers plus grands que byte :

Exemples d'utilisation de short :

short annee = 2024;
short distance = 15000;
short temperature = -50;

int (le plus utilisé)

Le type int est le type entier le plus couramment utilisé en Java. C'est le type par défaut pour les nombres entiers :

Exemples d'utilisation de int :

int nombre = 42;
int age = 30;
int population = 1000000;
int temperature = -25;

long

Le type long est utilisé pour les très grands nombres entiers. Notez le suffixe L ou l :

Exemples d'utilisation de long :

long populationMondiale = 8000000000L;
long distanceSoleil = 150000000000L;
long timestamp = 1234567890123L;

🔢 Types décimaux (float, double)

Les types décimaux permettent de stocker des nombres à virgule flottante (nombres réels) :

float

Le type float stocke des nombres décimaux avec une précision simple. Notez le suffixe f ou F :

Exemples d'utilisation de float :

float prix = 19.99f;
float temperature = -5.5f;
float pourcentage = 85.5f;

double (le plus utilisé pour les décimaux)

Le type double offre une précision double et est le type par défaut pour les nombres décimaux en Java :

Exemples d'utilisation de double :

double pi = 3.14159265359;
double prix = 29.99;
double moyenne = 15.75;

🔤 Type caractère (char)

Le type char stocke un seul caractère Unicode. Les caractères sont délimités par des apostrophes simples ' :

Exemples d'utilisation de char :

char lettre = 'A';
char chiffre = '5';
char symbole = '@';
char espace = ' ';

// Caractères spéciaux
char nouvelleLigne = '\n';  // Retour à la ligne
char tabulation = '\t';    // Tabulation
char guillemet = '\'';     // Apostrophe
char guillemetDouble = '\"'; // Guillemet double

✅ Type booléen (boolean)

Le type boolean ne peut avoir que deux valeurs : true (vrai) ou false (faux). Il est utilisé pour les conditions et les expressions logiques :

Exemples d'utilisation de boolean :

boolean estActif = true;
boolean estVide = false;
boolean estMajeur = true;
boolean aTermine = false;

📝 Déclaration et initialisation de variables

Pour utiliser une variable, vous devez d'abord la déclarer (et éventuellement l'initialiser) :

Syntaxe de déclaration

type nomVariable = valeur;

Exemples

Déclaration et initialisation :

// Déclaration et initialisation en une ligne
int age = 25;
double prix = 19.99;
char lettre = 'A';
boolean actif = true;

// Déclaration puis initialisation séparée
int nombre;
nombre = 10;

// Déclaration de plusieurs variables du même type
int x, y, z;
x = 1;
y = 2;
z = 3;

⚠️ Règles importantes

• Nom de variable : Doit commencer par une lettre, un underscore _ ou un dollar $
• Caractères autorisés : Lettres, chiffres, underscore, dollar
• Sensibilité à la casse : age et Age sont deux variables différentes
• Mots-clés réservés : Ne peuvent pas être utilisés comme noms de variables (class, public, static, etc.)
• Convention de nommage : Utilisez camelCase (première lettre minuscule, puis majuscules pour les mots suivants)

Exemples de noms de variables :

int age;              // ✅ Correct
int ageUtilisateur;   // ✅ Correct (camelCase)
int _temp;            // ✅ Correct
int $count;           // ✅ Correct (mais peu utilisé)
int 2nombre;          // ❌ Incorrect (ne peut pas commencer par un chiffre)
int mon-nom;          // ❌ Incorrect (tiret non autorisé)
int class;            // ❌ Incorrect (mot-clé réservé)
int Age;              // ✅ Correct (mais différent de 'age')

💡 Points clés à retenir

• 8 types primitifs : byte, short, int, long, float, double, char, boolean
• int : Type entier le plus utilisé
• double : Type décimal le plus utilisé
• Suffixes : L pour long, f pour float
• char : Un seul caractère avec apostrophes simples 'A'
• boolean : Seulement true ou false
• Déclaration : type nomVariable = valeur;
• Nommage : camelCase, commence par une lettre