Wat zijn primitive types versus reference types in Java?

Question

Accepted Answer

Java heeft twee fundamentele type-categorieën: **primitives** (eenvoudige waarden die rechtstreeks worden opgeslagen) en **reference types** (objecten, waarbij de variabele een referentie/pointer naar het object bevat). Ze gedragen zich zeer verschillend in geheugen, toewijzing en vergelijking. ## De 8 primitive types ```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 ``` Primitives slaan de **werkelijke waarde** rechtstreeks op, hebben een vaste grootte, kunnen niet null zijn, en bevinden zich op de stack (voor lokale variabelen). Ze zijn snel en geheugenefficiënt. ## Reference types — objecten ```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 ``` Referentievariabelen bevatten een **referentie** (geheugenadres) naar een object dat op de heap is opgeslagen — niet het object zelf. Ze kunnen `null` zijn. ## Het kritieke verschil: toewijzing en vergelijking ```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 ``` Dit is een groot probleem: **`==` op objecten vergelijkt identiteit (hetzelfde object?), niet inhoud** — gebruik `.equals()` voor inhouds vergelijking. ## 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 ``` Elke primitive heeft een wrapper-klasse (`int`→`Integer`, enz.) zodat primitives kunnen worden gebruikt waar objecten vereist zijn (collections, generics). ## Waarom het belangrijk is Het onderscheid primitive-versus-reference is fundamenteel voor Java en de bron van veel subtiele bugs en gedragingen: toewijzing kopieert waarden voor primitives maar deelt referenties voor objecten (dus het wijzigen van een gedeeld object beïnvloedt alle referenties), en vooral dat **`==` identiteit voor objecten vergelijkt** (een klassieke fout — gebruik `.equals()` voor inhouds vergelijking). Dit inzicht beïnvloedt de juistheid in vergelijkingen, methode-argumenten (objecten worden effectief per referentie-waarde doorgegeven), null-verwerking (alleen referenties kunnen null zijn) en prestaties (primitives zijn lichter). Het is essentiële kennis voor het schrijven van correct Java.