0Pricing
Java Academy · Leçon

Types primitifs et types de référence

Comprenez la différence fondamentale entre les types primitifs et les types de référence en Java.

Types primitifs et types de référence est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.

Types primitifs et types de référence

Java possède deux grandes catégories fondamentales de types de données : les types primitifs et les types de référence. Comprendre cette différence est essentiel pour écrire du code Java correct et efficace.

Les huit types primitifs

Java possède exactement huit types primitifs :

  • byte (entier sur 8 bits)
  • short (entier sur 16 bits)
  • int (entier sur 32 bits)
  • long (entier sur 64 bits)
  • float (nombre décimal sur 32 bits)
  • double (nombre décimal sur 64 bits)
  • char (caractère Unicode sur 16 bits)
  • boolean (vrai/faux)

Les primitifs contiennent directement la valeur en mémoire, sans surcharge liée à un objet.

int age = 25;
double price = 19.99;
boolean active = true;
char grade = 'A';
long population = 8_000_000_000L;

System.out.println(age);       // 25
System.out.println(price);     // 19.99
System.out.println(active);    // true

Types de référence

Un type de référence stocke une adresse mémoire (la référence) qui pointe vers un objet du tas. Cela comprend :

  • Les classes (par exemple, String et Scanner)
  • Les tableaux (par exemple, int[])
  • Les interfaces
  • Les énumérations et les enregistrements

La variable ne contient pas l'objet : elle contient un pointeur vers celui-ci.

String name = "Alice";       // reference to a String object
int[] scores = {90, 85, 92}; // reference to an array object

// name holds a reference, not the characters directly
System.out.println(name.length());   // 5
System.out.println(scores.length);   // 3

Mémoire de pile et mémoire de tas

Les variables primitives sont stockées sur la pile, une mémoire rapide et de courte durée associée aux appels de méthodes.

Les objets de types de référence résident dans le tas, une mémoire plus grande et de longue durée gérée par le ramasse-miettes. La référence (l'adresse) elle-même se trouve sur la pile.

// Stack: holds the int value directly
int x = 42;

// Stack: holds reference; Heap: holds the Person object
class Person {
    String name;
    int age;
}

Person p = new Person(); // p is a reference on stack, object on heap
p.name = "Bob";
p.age = 30;

null : la référence absente

Les variables de référence peuvent recevoir null, ce qui signifie qu'elles ne pointent vers aucun objet. Les primitifs ne peuvent pas être null : ils ont toujours une valeur.

L'accès à une référence null provoque une NullPointerException (NPE), l'une des erreurs d'exécution les plus courantes de Java.

String s = null;
// int n = null; // Compile error — primitives can't be null

try {
    System.out.println(s.length()); // NullPointerException!
} catch (NullPointerException e) {
    System.out.println("Caught NPE: reference was null");
}

Sémantique de copie : primitifs

Lorsque vous affectez une variable primitive à une autre, Java copie la valeur. Modifier l'une ne modifie pas l'autre : elles sont totalement indépendantes.

int a = 10;
int b = a;  // b gets a copy of the value 10

b = 20;     // changing b does NOT affect a

System.out.println(a); // 10
System.out.println(b); // 20

Sémantique de copie : références

Lorsque vous affectez une variable de référence à une autre, les deux variables pointent vers le même objet. Modifier l'objet par l'intermédiaire d'une référence est visible par l'intermédiaire de l'autre.

int[] arr1 = {1, 2, 3};
int[] arr2 = arr1; // arr2 points to the SAME array

arr2[0] = 99; // modifies the shared array

System.out.println(arr1[0]); // 99 — arr1 sees the change too!
System.out.println(arr2[0]); // 99

Classes enveloppes : boxing des primitifs

Chaque primitif possède une classe enveloppe correspondante dans java.lang :

  • int → Integer
  • double → Double
  • boolean → Boolean
  • char → Character

Les enveloppes permettent d'utiliser les primitifs comme des objets, ce qui est nécessaire pour les collections telles que List<Integer>.

Integer boxed = Integer.valueOf(42); // explicit boxing
int unboxed = boxed.intValue();       // explicit unboxing

// Autoboxing / auto-unboxing (Java does this automatically)
Integer auto = 100;  // autoboxed
int val = auto;      // auto-unboxed

System.out.println(Integer.MAX_VALUE);  // 2147483647
System.out.println(Double.MIN_VALUE);   // 5.0E-324

Pièges de l'autoboxing

L'autoboxing est pratique, mais peut provoquer des erreurs subtiles. Integer met en cache les valeurs de -128 à 127 ; en dehors de cette plage, == compare les références et non les valeurs.

Utilisez toujours .equals() pour comparer des objets enveloppes.

Integer a = 127;
Integer b = 127;
System.out.println(a == b);      // true (cached)

Integer c = 200;
Integer d = 200;
System.out.println(c == d);      // false (different objects!)
System.out.println(c.equals(d)); // true (correct comparison)

Passage aux méthodes : passage par valeur

Java utilise toujours le passage par valeur. Pour les primitifs, la valeur est copiée. Pour les références, la référence (l'adresse) est copiée : les deux références pointent vers le même objet, mais vous ne pouvez pas réaffecter la variable de l'appelant depuis l'intérieur de la méthode.

static void doubleValue(int n) {
    n = n * 2; // only modifies the local copy
}

static void clearArray(int[] arr) {
    arr[0] = 0; // modifies the shared object
}

int x = 5;
doubleValue(x);
System.out.println(x); // still 5

int[] nums = {10, 20, 30};
clearArray(nums);
System.out.println(nums[0]); // 0 — object was mutated

Tableau récapitulatif pratique

Référence rapide comparant les primitifs et les types de référence :

  • Stockage : primitif → valeur sur la pile ; référence → adresse sur la pile + objet dans le tas
  • Valeur par défaut : primitif → 0/false/\u0000 ; référence → null
  • Peut être null : primitif → non ; référence → oui
  • La copie lors de l'affectation : primitif → valeur ; référence → adresse
  • Dans les collections : les primitifs nécessitent des classes enveloppes

Vérification rapide

Que se passe-t-il lorsque vous exécutez le code suivant ?

Integer x = 200;
Integer y = 200;
System.out.println(x == y);

Récapitulatif : types primitifs et types de référence

Points essentiels de cette leçon :

  • Java possède 8 types primitifs stockés directement sur la pile
  • Les types de référence stockent l'adresse d'un objet du tas ; la variable contient cette adresse
  • Les primitifs sont copiés par valeur ; les références sont copiées par adresse
  • Les variables de référence peuvent être null ; les primitifs ne le peuvent pas
  • Les classes enveloppes (Integer, Double, etc.) transforment les primitifs en objets
  • Java utilise toujours le passage par valeur, même lors du passage de références

Questions Fréquemment Posées

La leçon « Types primitifs et types de référence » est-elle gratuite ?

Oui — le texte complet de « Types primitifs et types de référence » 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 « Types primitifs et types de référence » ?

Comprenez la différence fondamentale entre les types primitifs et les types de référence en Java. 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 1 sur 4.

Combien de temps prend la leçon « Types primitifs et types de référence » ?

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