Quels sont les types primitifs par rapport aux types de référence en Java ?

Question

Accepted Answer

Java dispose de deux catégories fondamentales de types : les **primitifs** (valeurs simples stockées directement) et les **types de référence** (objets, où la variable contient une référence/pointeur vers l'objet). Ils se comportent très différemment en mémoire, lors de l'affectation et lors de la comparaison. ## Les 8 types primitifs ```java int i = 42; // 32-bit integer long l = 100L; // 64-bit integer double d = 3.14; // 64-bit floating point float f = 1.5f; // 32-bit floating point boolean b = true; // true/false char c = 'A'; // 16-bit Unicode character byte by = 127; // 8-bit short s = 1000; // 16-bit ``` Les primitifs stockent la **valeur réelle** directement, sont de taille fixe, ne peuvent pas être null, et résident sur la pile (pour les variables locales). Ils sont rapides et économes en mémoire. ## Types de référence — objets ```java String name = "Ann"; // reference to a String object int[] arr = {1, 2, 3}; // reference to an array object List list = new ArrayList<>(); // reference to a List object Person p = new Person("Bob"); // reference to a Person object ``` Les variables de référence contiennent une **référence** (adresse mémoire) à un objet stocké sur le tas — pas l'objet lui-même. Elles peuvent être `null`. ## La différence critique : affectation et comparaison ```java // primitives — assignment COPIES the value (independent) int a = 5; int b = a; // b is a COPY b = 10; // a is still 5 // references — assignment COPIES the reference (both point to the SAME object) int[] x = {1, 2, 3}; int[] y = x; // y points to the SAME array y[0] = 99; // x[0] is now 99 too! (shared object) ``` ```java // == compares VALUES for primitives, but REFERENCES (identity) for objects String s1 = new String("hi"); String s2 = new String("hi"); s1 == s2; // false — different objects (different references) s1.equals(s2); // true — equals() compares CONTENT ``` C'est un piège majeur : **`==` sur les objets compare l'identité (même objet ?), pas le contenu** — utilisez `.equals()` pour la comparaison de contenu. ## Les classes wrapper font le lien entre les deux ```java Integer boxed = 42; // Integer is the OBJECT wrapper for int (autoboxing) int unboxed = boxed; // auto-unboxing back to primitive List nums; // collections need objects, not primitives ``` Chaque primitif a une classe wrapper (`int`→`Integer`, etc.) pour que les primitifs puissent être utilisés là où des objets sont requis (collections, génériques). ## Pourquoi c'est important La distinction primitif-vs-référence est fondamentale en Java et source de nombreux bugs et comportements subtils : l'affectation copie les valeurs pour les primitifs mais partage les références pour les objets (donc modifier un objet partagé affecte toutes les références), et surtout que **`==` compare l'identité pour les objets** (une erreur classique — utilisez `.equals()` pour le contenu). La compréhension de cela affecte la correction des comparaisons, des arguments de méthode (les objets sont effectivement passés par valeur de référence), la gestion des null (seules les références peuvent être null), et les performances (les primitifs sont plus légers). C'est une connaissance fondamentale pour écrire du Java correct.