Was sind primitive Typen vs. Referenztypen in Java?

Question

Accepted Answer

Java hat zwei grundlegende Typkategorien: **Primitive** (einfache Werte, die direkt gespeichert werden) und **Referenztypen** (Objekte, bei denen die Variable eine Referenz/einen Zeiger auf das Objekt hält). Sie verhalten sich sehr unterschiedlich im Speicher, bei der Zuweisung und beim Vergleich. ## Die 8 primitiven Typen ```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 ``` Primitive speichern den **tatsächlichen Wert** direkt, haben feste Größe, können nicht null sein und befinden sich auf dem Stack (für lokale Variablen). Sie sind schnell und speichereffizient. ## Referenztypen — Objekte ```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 ``` Referenzvariablen halten eine **Referenz** (Speicheradresse) zu einem auf dem Heap gespeicherten Objekt — nicht das Objekt selbst. Sie können `null` sein. ## Der kritische Unterschied: Zuweisung und Vergleich ```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 ``` Dies ist eine große Fallgrube: **`==` bei Objekten vergleicht die Identität (gleiches Objekt?), nicht den Inhalt** — verwende `.equals()` für Inhaltsvergleich. ## Wrapper-Klassen verbinden beide ```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 ``` Jeder primitive Typ hat eine Wrapper-Klasse (`int`→`Integer`, etc.), damit Primitive dort verwendet werden können, wo Objekte erforderlich sind (Collections, Generics). ## Warum es wichtig ist Die Unterscheidung zwischen Primitive und Referenz ist fundamental für Java und die Quelle vieler subtiler Fehler und Verhaltensweisen: Zuweisung kopiert Werte bei Primitiven, teilt aber Referenzen bei Objekten (sodass das Ändern eines gemeinsamen Objekts alle Referenzen beeinflusst), und besonders dass **`==` bei Objekten die Identität vergleicht** (ein klassischer Fehler — verwende `.equals()` für Inhaltsvergleich). Das Verständnis hierfür wirkt sich auf die Korrektheit bei Vergleichen, Methodenargumenten (Objekte werden effektiv nach Referenzwert übergeben), Null-Behandlung (nur Referenzen können null sein) und Performance (Primitive sind leichter) aus. Es ist grundlegendes Wissen zum Schreiben von korrektem Java.