Jakie są typy pierwotne a jakie typy referencyjne w Javie?

Question

Accepted Answer

Java ma dwie fundamentalne kategorie typów: **primitives** (proste wartości przechowywane bezpośrednio) i **reference types** (obiekty, gdzie zmienna przechowuje referencję/wskaźnik do obiektu). Zachowują się one bardzo różnie w pamięci, przy przypisaniu i porównaniu. ## 8 typów pierwotnych ```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 ``` Typy pierwotne przechowują **rzeczywistą wartość** bezpośrednio, mają stały rozmiar, nie mogą być null i przebywają na stosie (dla zmiennych lokalnych). Są szybkie i efektywne pamięciowo. ## Typy referencyjne — obiekty ```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 ``` Zmienne referencyjne przechowują **referencję** (adres pamięci) do obiektu przechowywanego na stercie — nie samego obiektu. Mogą być `null`. ## Kluczowa różnica: przypisanie i porównanie ```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 ``` To jest duża pułapka: **`==` na obiektach porównuje tożsamość (ten sam obiekt?), nie zawartość** — użyj `.equals()` do porównania zawartości. ## Klasy opakowujące łączą obie kategorie ```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 ``` Każdy typ pierwotny ma klasę opakowującą (`int`→`Integer`, itp.) aby typy pierwotne mogły być używane tam, gdzie wymagane są obiekty (kolekcje, generyki). ## Dlaczego to ważne Rozdział między typami pierwszymi a referencyjnymi jest fundamentalny dla Javy i źródłem wielu subtelnych błędów i zachowań: przypisanie kopiuje wartości dla typów pierwotnych, ale udostępnia referencje dla obiektów (więc modyfikacja wspólnego obiektu wpływa na wszystkie referencje), a szczególnie, że **`==` porównuje tożsamość dla obiektów** (klasyczny błąd — użyj `.equals()` do porównania zawartości). Rozumienie tego wpływa na poprawność w porównaniach, argumentach metod (obiekty są efektywnie przekazywane przez wartość referencji), obsługę null (tylko referencje mogą być null) i wydajność (typy pierwotne są lżejsze). To jest podstawowa wiedza do pisania poprawnej Javy.