PricingLoginStart free
Java Academy · leksjon

Primitive typer kontra referansetyper

Forstå den grunnleggende forskjellen mellom primitive typer og referansetyper i Java.

Leksjon 1 av 413 trinn

Primitive typer kontra referansetyper er en gratis leksjon i Java Academy på CoddyKit. Dette er leksjon 1 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Java Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Java Academy inneholder totalt 4 leksjoner.

Primitive typer kontra referansetyper

Java har to grunnleggende kategorier av datatyper: primitive typer og referansetyper. Det er avgjørende å forstå forskjellen for å skrive korrekt og effektiv Java-kode.

De åtte primitive typene

Java har nøyaktig åtte primitive typer:

  • byte (8-bits heltall)
  • short (16-bits heltall)
  • int (32-bits heltall)
  • long (64-bits heltall)
  • float (32-bits desimaltall)
  • double (64-bits desimaltall)
  • char (16-bits Unicode-tegn)
  • boolean (true/false)

Primitive typer lagrer verdien direkte i minnet – uten overhead fra objekter.

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

Referansetyper

En referansetype lagrer en minneadresse (referanse) som peker til et objekt på heapen. Dette omfatter:

  • Klasser (f.eks. String, Scanner)
  • Tabeller (f.eks. int[])
  • Grensesnitt
  • Enum-typer og records

Variabelen inneholder ikke objektet – den inneholder en peker til det.

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

Minne på stacken kontra heapen

Primitive variabler lagres på stacken – raskt, kortvarig minne knyttet til metodekall.

Referansetypeobjekter ligger på heapen – større, langlivet minne som håndteres av søppeloppsamling. Selve referansen (adressen) ligger på stacken.

// 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: Den manglende referansen

Referansevariabler kan tilordeles null, som betyr at de ikke peker på noe objekt. Primitive typer kan ikke være null – de har alltid en verdi.

Tilgang til en nullreferanse fører til en NullPointerException (NPE) – en av de vanligste kjøretidsfeilene i 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");
}

Kopieringssemantikk: primitive typer

Når du tilordner en primitiv variabel til en annen, kopierer Java verdien. Hvis du endrer den ene, påvirkes ikke den andre – de er helt uavhengige.

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

Kopieringssemantikk: referanser

Når du tilordner en referansevariabel til en annen, peker begge variablene på det samme objektet. Endringer i objektet gjennom den ene referansen er synlige gjennom den andre.

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-klasser: boksing av primitive typer

Hver primitiv type har en tilsvarende wrapper-klasse i java.lang:

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

Wrappere lar deg bruke primitive typer som objekter – noe som kreves for samlinger som 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

Fallgruver ved autoboxing

Autoboxing er praktisk, men kan føre til subtile feil. Integer cacher verdier fra -128 til 127 – utenfor dette området sammenligner == referanser, ikke verdier.

Bruk alltid .equals() til å sammenligne wrapper-objekter.

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)

Overføring til metoder: pass-by-value

Java bruker alltid pass-by-value. For primitive typer kopieres verdien. For referanser kopieres referansen (adressen) – begge peker på det samme objektet, men du kan ikke tilordne den kallende variabelen på nytt fra innsiden av metoden.

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

Praktisk oppsummeringstabell

En rask sammenligning av primitive typer og referansetyper:

  • Lagring: primitiv type → verdi på stacken; referanse → adresse på stacken + objekt på heapen
  • Standardverdi: primitiv type → 0/false/\u0000; referanse → null
  • Kan være null: primitiv type → Nei; referanse → Ja
  • Tilordning kopierer: primitiv type → verdi; referanse → adresse
  • I samlinger: primitive typer trenger wrapper-klasser

Rask kontroll

Hva skjer når du kjører følgende kode?

Integer x = 200;
Integer y = 200;
System.out.println(x == y);
Besvar den i den interaktive leksjonen

Oppsummering: primitive typer kontra referansetyper

Dette er de viktigste punktene fra leksjonen:

  • Java har 8 primitive typer som lagres direkte på stacken
  • Referansetyper lagrer adressen til et objekt på heapen; variabelen inneholder adressen
  • Primitive typer kopieres som verdier; referanser kopieres som adresser
  • Referansevariabler kan være null; primitive typer kan ikke
  • Wrapper-klasser (Integer, Double osv.) bokser primitive typer som objekter
  • Java bruker alltid pass-by-value – også når referanser sendes som argumenter
Gratis å komme i gang

Lær deg Java med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs
104
Leksjoner
374
Start læringen gratisSe hele kurset

Ofte stilte spørsmål

Er leksjonen «Primitive typer kontra referansetyper» gratis?

Ja – hele teksten i «Primitive typer kontra referansetyper» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Java Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Java Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Primitive typer kontra referansetyper»?

Forstå den grunnleggende forskjellen mellom primitive typer og referansetyper i Java. Du øver på Java Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Java Academy?

Ingen tidligere erfaring er nødvendig. Java Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.

Hvor lang tid tar leksjonen «Primitive typer kontra referansetyper»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Java Academy-leksjonen?

Ja. Alle Java Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

  1. Primitive typer kontra referansetyper
  2. Utvidende og innsnevrende konverteringer
  3. instanceof-operatoren
  4. Typekonvertering i praksis
← Tilbake til Java Academy