1.2 Types et Variables

En Java, toute variable a un type declare explicitement. C'est un langage a typage statique fort — contrairement a PHP ou Python ou le type peut changer.

1. Types primitifs

Les types primitifs sont les briques de base. Ils ont toujours une valeur par defaut et sont stockes directement en memoire (pas d'objet).

Type	Valeur par defaut	Usage	Exemple
`int`	0	Entier courant	`int age = 21;`
`long`	0	Grand entier	`long taille = 1_000_000L;`
`double`	0.0	Decimal	`double prix = 9.99;`
`boolean`	false	Vrai/Faux	`boolean actif = true;`
`char`	`''`	Caractere unique	`char lettre = 'A';`
`byte`	0	Petit entier (-128 a 127)	`byte b = 100;`

Comparaison PHP : En PHP $age = 21 peut devenir une chaine plus tard. En Java int age = 21 sera toujours un entier — le compilateur refuse le reste.

2. Types complexes (objets)

Les types complexes sont des objets. Leur valeur par defaut est null si non initialises.

String nom = "Florian";      // chaine de caracteres
String vide = null;          // valeur par defaut si non initialise

int[] notes = {15, 18, 12}; // tableau d'entiers

Appeler une methode sur null provoque une NullPointerException (NPE) — l'erreur la plus frequente en Java.

3. Inference de type avec `var` (Java 10+)

Le mot-cle var laisse Java deviner le type. Pratique, mais utiliser avec moderation — le type doit rester lisible au premier coup d'oeil.

var age = 21;            // Java devine : int
var nom = "Florian";     // Java devine : String
var notes = new int[]{15, 18, 12}; // Java devine : int[]

// Interdit : Java ne peut pas deviner sans valeur initiale
var x; // ERREUR de compilation

4. Constantes avec `final`

Le mot-cle final empeche la reassignation. Convention : nom en MAJUSCULES.

final int TAILLE_MAX = 100;
TAILLE_MAX = 200; // ERREUR de compilation

final String NOM_APP = "JBDC";

Comparaison PHP : Equivalent de const TAILLE_MAX = 100; en PHP.

5. Conversions de types

// Implicite (pas de perte) : int -> long -> double
int i = 42;
double d = i;    // OK automatique

// Explicite (cast) : risque de perte
double pi = 3.14;
int entier = (int) pi;  // entier = 3, la decimale est perdue

// String <-> nombre
String s = String.valueOf(42);   // int -> String
int n = Integer.parseInt("42");  // String -> int

JBDC — Apercu

Les types vus ici seront utilises dans les entites JBDC qu'on creera en phase 2 :

// Dans Fichier.java (phase 2)
String nom;          // nom du fichier
long taille;         // taille en octets
String extension;    // "pdf", "jpg", "mp4"...
boolean disponible;  // fichier encore accessible ?

// Dans Utilisateur.java (phase 2)
String email;
String motDePasse;

// Constante globale
final long TAILLE_MAX = 2_000_000_000L; // 2 Go

Precedent : Environnement Suivant : Methodes et static