Hva er primitive typer versus referansetyper i Java?

Question

Accepted Answer

Java har to grunnleggende typekategorier: **primitives** (enkle verdier lagret direkte) og **referansetyper** (objekter, der variabelen inneholder en referanse/peker til objektet). De oppfører seg veldig forskjellig i minne, tilordning og sammenligning. ## De 8 primitive typene ```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 lagrer den **faktiske verdien** direkte, har fast størrelse, kan ikke være null, og befinner seg på stacken (for lokale variabler). De er raske og minneseffektive. ## Referansetyper — objekter ```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 ``` Referansevariabel holder en **referanse** (minneadresse) til et objekt lagret på heapen — ikke objektet selv. De kan være `null`. ## Den kritiske forskjellen: tilordning og sammenligning ```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 ``` Dette er en stor gotcha: **`==` på objekter sammenligner identitet (samme objekt?), ikke innhold** — bruk `.equals()` for innholdssammenligning. ## Wrapper-klasser bygger bro mellom de to ```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 ``` Hver primitive har en wrapper-klasse (`int`→`Integer`, osv.) slik at primitives kan brukes der objekter er påkrevd (collections, generics). ## Hvorfor det betyr noe Distinksjonen primitive-versus-referanse er fundamental for Java og kilden til mange subtile bugs og atferd: tilordning kopierer verdier for primitives men deler referanser for objekter (så endring av et delt objekt påvirker alle referanser), og spesielt at **`==` sammenligner identitet for objekter** (en klassisk feil — bruk `.equals()` for innholdssammenligning). Forståelse av dette påvirker korrekthet i sammenligninger, metodargumenter (objekter gis effektivt videre etter referanseverdi), null-håndtering (bare referanser kan være null), og ytelse (primitives er lettere). Det er kjernekunnskap for å skrive korrekt Java.