Care sunt tipurile primitive față de tipurile de referință în Java?

Question

IT Interview Practice · Accepted Answer

Java are două categorii fundamentale de tipuri: **primitive** (valori simple stocate direct) și **tipuri de referință** (obiecte, unde variabila conține o referință/pointer la obiect). Se comportă foarte diferit în memorie, atribuire și comparare. ## Cele 8 tipuri primitive ```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 ``` Tipurile primitive stochează **valoarea reală** direct, au dimensiune fixă, nu pot fi null și trăiesc pe stivă (pentru variabilele locale). Sunt rapide și eficiente din punct de vedere al memoriei. ## Tipuri de referință — obiecte ```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 ``` Variabilele de referință dețin o **referință** (adresă de memorie) la un obiect stocat pe heap — nu obiectul în sine. Pot fi `null`. ## Diferența critică: atribuire și comparare ```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 ``` Acesta este o problemă majoră: **`==` pe obiecte compară identitatea (același obiect?), nu conținutul** — folosiți `.equals()` pentru compararea conținutului. ## Clasele wrapper conectează cele două ```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 ``` Fiecare tip primitiv are o clasă wrapper (`int`→`Integer`, etc.) pentru ca tipurile primitive să poată fi folosite acolo unde sunt necesare obiecte (colecții, generice). ## De ce este important Distincția primitiv-versus-referință este fundamentală pentru Java și sursa multor erori subtile și comportamente: atribuirea copiază valorile pentru primitive, dar împărtășește referințele pentru obiecte (deci modificarea unui obiect împărțit afectează toate referințele), și în special că **`==` compară identitatea pentru obiecte** (o greșeală clasică — folosiți `.equals()` pentru compararea conținutului). Înțelegerea acestui lucru afectează corectitudinea în comparații, argumente de metodă (obiectele sunt transmise efectiv după valoare de referință), gestionarea null (doar referințele pot fi null) și performanță (primitive sunt mai ușoare). Este cunoștințe fundamentale pentru a scrie Java corect.

Cele 8 tipuri primitive

Tipuri de referință — obiecte

Diferența critică: atribuire și comparare

Clasele wrapper conectează cele două

De ce este important

Întrebări conexe