Jaké jsou primitivní typy versus referenční typy v Javě?

Question

Accepted Answer

Java má dvě základní kategorie typů: **primitivy** (jednoduché hodnoty uložené přímo) a **referenční typy** (objekty, kde proměnná drží odkaz/ukazatel na objekt). Chování se velmi liší v paměti, přiřazení a porovnání. ## 8 primitivních typů ```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 ``` Primitivy ukládají **skutečnou hodnotu** přímo, mají pevnou velikost, nemohou být null a existují v stacku (pro lokální proměnné). Jsou rychlé a paměťově efektivní. ## Referenční typy — objekty ```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 ``` Referenční proměnné drží **odkaz** (adresu v paměti) na objekt uložený na haldě — ne na samotný objekt. Mohou být `null`. ## Kritický rozdíl: přiřazení a porovnání ```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 ``` Je to velký catch: **`==` u objektů porovnává identitu (stejný objekt?), ne obsah** — použijte `.equals()` pro porovnání obsahu. ## Třídy Wrapper spojují obě 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ždý primitivní typ má třídu wrapper (`int`→`Integer`, atd.), takže primitivy lze používat tam, kde jsou požadovány objekty (kolekce, generiky). ## Proč je to důležité Rozdíl mezi primitivy a referencemi je zásadní pro Javu a zdrojem mnoha jemných chyb a chování: přiřazení kopíruje hodnoty pro primitivy, ale sdílí reference pro objekty (takže úprava sdíleného objektu ovlivní všechny reference), a zejména to, že **`==` porovnává identitu pro objekty** (klasická chyba — použijte `.equals()` pro porovnání obsahu). Porozumění tomuto ovlivňuje správnost v porovnáních, argumentech metod (objekty jsou efektivně předány hodnotou reference), zpracování null (pouze reference mohou být null) a výkon (primitivy jsou lehčí). Je to základní znalost pro psaní správné Javy.