Java Academy · Lektion

Primitive typer vs. referencetyper

Forstå den grundlæggende forskel mellem primitive typer og referencetyper i Java.

Lektion 1 af 413 trin

Primitive typer vs. referencetyper er en gratis Java Academy-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Java Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Java Academy-kurset indeholder 4 lektioner i alt.

Primitive typer kontra referencetyper

Java har to grundlæggende kategorier af datatyper: primitive typer og referencetyper. Det er afgørende at forstå forskellen for at skrive korrekt og effektiv Java-kode.

De otte primitive typer

Java har præcis otte primitive typer:

byte (heltal på 8 bit)
short (heltal på 16 bit)
int (heltal på 32 bit)
long (heltal på 64 bit)
float (decimaltal på 32 bit)
double (decimaltal på 64 bit)
char (Unicode-tegn på 16 bit)
boolean (sand/falsk)

Primitive typer gemmer værdien direkte i hukommelsen – uden 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

Referencetyper

En referencetype gemmer en hukommelsesadresse (reference), der peger på et objekt på heapen. Dette omfatter:

Klasser (f.eks. String, Scanner)
Arrays (f.eks. int[])
Grænseflader
Enumtyper og recordtyper

Variablen indeholder ikke objektet – den indeholder en peger 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

Stack- og heap-hukommelse

Primitive variabler gemmes på stacken – hurtig, kortvarig hukommelse, der er knyttet til metodekald.

Objekter af referencetyper lever på heapen – større, langvarig hukommelse, der administreres af garbage collection. Selve referencen (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 reference

Referencevariabler kan tildeles null, hvilket betyder, at de ikke peger på noget objekt. Primitive typer kan ikke være null – de har altid en værdi.

Adgang til en null-reference forårsager en NullPointerException (NPE) – en af Javas mest almindelige kørselsfejl.

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");
}

Kopieringssemantik: primitive typer

Når du tildeler en primitiv variabel til en anden, kopierer Java værdien. Hvis du ændrer den ene, påvirker det ikke den anden – de er helt uafhængige.

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

Kopieringssemantik: referencer

Når du tildeler en referencevariabel til en anden, peger begge variabler på det samme objekt. Ændringer af objektet via den ene reference kan ses via den anden.

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: indpakning af primitive værdier

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

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

Wrapper-klasser gør det muligt at bruge primitive værdier som objekter – det er nødvendigt 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

Faldgruber ved autoboxing

Autoboxing er praktisk, men kan medføre svære fejl. Integer cacher værdier fra -128 til 127 – uden for dette interval sammenligner == referencer, ikke værdier.

Brug altid .equals() til at 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ørsel til metoder: værdioverførsel

Java bruger altid værdioverførsel. For primitive typer kopieres værdien. For referencer kopieres referencen (adressen) – begge peger på det samme objekt, men du kan ikke tildele den kaldendes variabel på ny indefra 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 oversigtstabel

Hurtig oversigt over forskellen på primitive typer og referencetyper:

Lagring: primitiv → værdi på stacken; reference → adresse på stacken + objekt på heapen
Standardværdi: primitiv → 0/false/\u0000; reference → null
Kan være null: primitiv → Nej; reference → Ja
Tildeling kopierer: primitiv → værdi; reference → adresse
I samlinger: primitive typer kræver wrapper-klasser

Hurtigt tjek

Hvad sker der, når du udfører følgende kode?

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

Besvar den i den interaktive lektion

Opsummering: primitive typer kontra referencetyper

Vigtige konklusioner fra denne lektion:

Java har 8 primitive typer, der gemmes direkte på stacken
Referencetyper gemmer adressen på et objekt på heapen; variablen indeholder adressen
Primitive typer kopieres som værdier; referencer kopieres som adresser
Referencevariabler kan være null; primitive typer kan ikke
Wrapper-klasser (Integer, Double osv.) pakker primitive typer ind som objekter
Java bruger altid værdioverførsel – også når referencer overføres

Gratis at komme i gang

Lær Java med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 104
Lektioner: 374

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Primitive typer vs. referencetyper” gratis?

Ja — hele teksten til “Primitive typer vs. referencetyper” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Java Academy-kurset, skal du opgradere til CoddyKit PRO. Java Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Primitive typer vs. referencetyper”?

Forstå den grundlæggende forskel mellem primitive typer og referencetyper i Java. Du øver dig i Java Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Java Academy?

Der kræves ingen tidligere erfaring. Java Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.

Hvor lang tid tager lektionen “Primitive typer vs. referencetyper”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Java Academy-lektion?

Ja. Alle Java Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Primitive typer vs. referencetyper
Udvidende og indsnævrende konverteringer
Operatoren instanceof
Typecasting i praksis

← Tilbage til Java Academy