0Pricing
Java Academy · Lektion

Primitive Datentypen vs. Referenztypen

Verstehen Sie den grundlegenden Unterschied zwischen primitiven Datentypen und Referenztypen in Java.

Primitive Datentypen vs. Referenztypen ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Primitive und Referenztypen

Java hat zwei grundlegende Kategorien von Datentypen: primitive Typen und Referenztypen. Das Verständnis dieses Unterschieds ist entscheidend, um korrekten und effizienten Java-Code zu schreiben.

Die acht primitiven Typen

Java hat genau acht primitive Typen:

  • byte (8-Bit-Ganzzahl)
  • short (16-Bit-Ganzzahl)
  • int (32-Bit-Ganzzahl)
  • long (64-Bit-Ganzzahl)
  • float (32-Bit-Gleitkommazahl)
  • double (64-Bit-Gleitkommazahl)
  • char (16-Bit-Unicode-Zeichen)
  • boolean (true/false)

Primitive Typen speichern den Wert direkt im Speicher – ohne Overhead durch Objekte.

int age = 25;
double price = 19.99;
boolean active = true;
char grade = 'A';
long population = 8_000_000_000L;

System.out.println(age);       // 25
System.out.println(price);     // 19.99
System.out.println(active);    // true

Referenztypen

Ein Referenztyp speichert eine Speicheradresse (Referenz), die auf ein Objekt im Heap verweist. Dazu gehören:

  • Klassen (z. B. String, Scanner)
  • Arrays (z. B. int[])
  • Interfaces
  • Enums und Records

Die Variable enthält nicht das Objekt, sondern einen Zeiger darauf.

String name = "Alice";       // reference to a String object
int[] scores = {90, 85, 92}; // reference to an array object

// name holds a reference, not the characters directly
System.out.println(name.length());   // 5
System.out.println(scores.length);   // 3

Stack- und Heap-Speicher

Primitive Variablen werden auf dem Stack gespeichert – in einem schnellen, kurzlebigen Speicher, der an Methodenaufrufe gebunden ist.

Objekte von Referenztypen liegen im Heap – einem größeren, langlebigen Speicher, der von der Garbage Collection verwaltet wird. Die Referenz (Adresse) selbst liegt auf dem Stack.

// Stack: holds the int value directly
int x = 42;

// Stack: holds reference; Heap: holds the Person object
class Person {
    String name;
    int age;
}

Person p = new Person(); // p is a reference on stack, object on heap
p.name = "Bob";
p.age = 30;

null: Die fehlende Referenz

Referenzvariablen können null zugewiesen bekommen. Das bedeutet, dass sie auf kein Objekt verweisen. Primitive Werte können nicht null sein – sie haben immer einen Wert.

Der Zugriff auf eine null-Referenz verursacht eine NullPointerException (NPE) – einen der häufigsten Laufzeitfehler in Java.

String s = null;
// int n = null; // Compile error — primitives can't be null

try {
    System.out.println(s.length()); // NullPointerException!
} catch (NullPointerException e) {
    System.out.println("Caught NPE: reference was null");
}

Kopiersemantik: Primitive Werte

Wenn Sie eine primitive Variable einer anderen zuweisen, kopiert Java den Wert. Eine Änderung der einen Variable wirkt sich nicht auf die andere aus – beide sind vollständig unabhängig.

int a = 10;
int b = a;  // b gets a copy of the value 10

b = 20;     // changing b does NOT affect a

System.out.println(a); // 10
System.out.println(b); // 20

Kopiersemantik: Referenzen

Wenn Sie eine Referenzvariable einer anderen zuweisen, verweisen beide Variablen auf dasselbe Objekt. Änderungen am Objekt über die eine Referenz sind über die andere sichtbar.

int[] arr1 = {1, 2, 3};
int[] arr2 = arr1; // arr2 points to the SAME array

arr2[0] = 99; // modifies the shared array

System.out.println(arr1[0]); // 99 — arr1 sees the change too!
System.out.println(arr2[0]); // 99

Wrapper-Klassen: Primitive Werte boxen

Zu jedem primitiven Typ gibt es eine entsprechende Wrapper-Klasse in java.lang:

  • int → Integer
  • double → Double
  • boolean → Boolean
  • char → Character

Wrapper ermöglichen die Verwendung primitiver Werte als Objekte – erforderlich für Collections wie List<Integer>.

Integer boxed = Integer.valueOf(42); // explicit boxing
int unboxed = boxed.intValue();       // explicit unboxing

// Autoboxing / auto-unboxing (Java does this automatically)
Integer auto = 100;  // autoboxed
int val = auto;      // auto-unboxed

System.out.println(Integer.MAX_VALUE);  // 2147483647
System.out.println(Double.MIN_VALUE);   // 5.0E-324

Fallstricke beim Autoboxing

Autoboxing ist praktisch, kann aber subtile Fehler verursachen. Integer cached Werte von -128 bis 127 – außerhalb dieses Bereichs vergleicht == Referenzen und nicht Werte.

Verwenden Sie zum Vergleichen von Wrapper-Objekten immer .equals().

Integer a = 127;
Integer b = 127;
System.out.println(a == b);      // true (cached)

Integer c = 200;
Integer d = 200;
System.out.println(c == d);      // false (different objects!)
System.out.println(c.equals(d)); // true (correct comparison)

Übergabe an Methoden: Wertübergabe

Java verwendet immer Wertübergabe. Bei primitiven Werten wird der Wert kopiert. Bei Referenzen wird die Referenz (Adresse) kopiert – beide verweisen auf dasselbe Objekt, aber Sie können die Variable des Aufrufers innerhalb der Methode nicht neu zuweisen.

static void doubleValue(int n) {
    n = n * 2; // only modifies the local copy
}

static void clearArray(int[] arr) {
    arr[0] = 0; // modifies the shared object
}

int x = 5;
doubleValue(x);
System.out.println(x); // still 5

int[] nums = {10, 20, 30};
clearArray(nums);
System.out.println(nums[0]); // 0 — object was mutated

Praktische Übersichtstabelle

Schnellübersicht zum Vergleich primitiver und referenzbasierter Typen:

  • Speicherung: primitive Typen → Wert auf dem Stack; Referenzen → Adresse auf dem Stack + Objekt im Heap
  • Standardwert: primitive Typen → 0/false/\u0000; Referenzen → null
  • Kann null sein: primitive Typen → Nein; Referenzen → Ja
  • Bei Zuweisung kopiert: primitive Typen → Wert; Referenzen → Adresse
  • In Collections: primitive Typen benötigen Wrapper-Klassen

Kurztest

Was geschieht bei der Ausführung des folgenden Codes?

Integer x = 200;
Integer y = 200;
System.out.println(x == y);

Zusammenfassung: Primitive und Referenztypen

Die wichtigsten Erkenntnisse aus dieser Lektion:

  • Java hat 8 primitive Typen, die direkt auf dem Stack gespeichert werden
  • Referenztypen speichern die Adresse eines Objekts im Heap; die Variable enthält diese Adresse
  • Primitive Werte werden per Wert kopiert; Referenzen werden per Adresse kopiert
  • Referenzvariablen können null sein; primitive Variablen nicht
  • Wrapper-Klassen (Integer, Double usw.) verpacken primitive Werte als Objekte
  • Java verwendet immer Wertübergabe – auch bei der Übergabe von Referenzen

Häufig gestellte Fragen

Ist die Lektion „Primitive Datentypen vs. Referenztypen“ kostenlos?

Ja — der vollständige Text von „Primitive Datentypen vs. Referenztypen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Primitive Datentypen vs. Referenztypen“?

Verstehen Sie den grundlegenden Unterschied zwischen primitiven Datentypen und Referenztypen in Java. Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Primitive Datentypen vs. Referenztypen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Primitive Datentypen vs. Referenztypen
  2. Verbreiterungs- und Verengungskonvertierungen
  3. Der instanceof-Operator
  4. Typ-Casting in der Praxis
← Zurück zu Java Academy