Java Academy · Lektion

Pass-by-value i Java

Forstå Javas pass-by-value: primitive typer kontra referencer, gentildeling kontra mutation samt faldgruber med arrays og uforanderlighed.

Lektion 1 af 38 trin

Pass-by-value i Java er en gratis Java Academy-lektion på CoddyKit. Dette er lektion 1 af 3. 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 3 lektioner i alt.

Oversigt over værdiparametre

Mål: Lær, hvordan Java videregiver parametre. Sammenlign primitive typer og referencer, omtilordning og ændring, arrays samt uforanderlighed.

Kopiering af primitive værdier

Primitive værdier videregives som værdier: Den kaldte metode får en kopi. Hvis du omtilordner parameteren, ændrer det ikke kalderens variabel.

public class Main {
  static void inc(int x) {
    x = x + 1; // modifies the local copy only
  }
  public static void main(String[] args) {
    int a = 5;
    inc(a);
    System.out.println("a after inc(a) = " + a); // still 5
  }
}

Referencer: ændring eller omtilordning

For objekter kopieres referencen. Hvis du ændrer objektet gennem referencen, påvirker det kalderens objekt; hvis du omtilordner parameteren, gør det ikke.

public class Main {
  static class Box { int n; }
  static void setTo999(Box b) { b.n = 999; } // mutate via copied reference
  static void reassign(Box b) { b = new Box(); b.n = 123; } // reassign local copy only
  public static void main(String[] args) {
    Box bx = new Box();
    bx.n = 10;
    setTo999(bx);
    System.out.println("after setTo999: bx.n = " + bx.n); // 999
    reassign(bx);
    System.out.println("after reassign: bx.n = " + bx.n); // still 999
  }
}

Arrays: ændring eller omtilordning

Arrays er objekter. Ændr arrayet for at påvirke kalderens objekt; omtilordning af parameteren erstatter ikke kalderens array.

public class Main {
  static void fillZero(int[] a) {
    for (int i = 0; i < a.length; i = i + 1) a[i] = 0; // mutate caller array
  }
  static void replace(int[] a) {
    a = new int[] {9, 9, 9}; // reassign local copy of the reference
  }
  public static void main(String[] args) {
    int[] arr = {1, 2, 3};
    fillZero(arr);
    System.out.println("after fillZero: " + arr[0] + "," + arr[1] + "," + arr[2]); // 0,0,0
    replace(arr);
    System.out.println("after replace:  " + arr[0] + "," + arr[1] + "," + arr[2]); // still 0,0,0
  }
}

Uforanderlig eller foranderlig

String er uforanderlig og returnerer nye objekter; StringBuilder er foranderlig og ændrer den samme instans.

public class Main {
  static void tryChangeString(String s) {
    s = s + "!"; // new String; original unchanged
  }
  static void changeBuilder(StringBuilder sb) {
    sb.append("!"); // mutates same object
  }
  public static void main(String[] args) {
    String s = "hi";
    tryChangeString(s);
    System.out.println("after tryChangeString: " + s); // "hi"

    StringBuilder sb = new StringBuilder("hi");
    changeBuilder(sb);
    System.out.println("after changeBuilder:  " + sb.toString()); // "hi!"
  }
}

Byt korrekt

Fordi parametre er kopier, påvirker det ikke kalderen at bytte primitive værdier inde i en metode. Returnér nye værdier eller brug et beholderobjekt.

public class Main {
  static void trySwap(int a, int b) {
    int t = a; a = b; b = t; // swaps local copies only
  }
  static int[] swap(int a, int b) {
    return new int[] { b, a }; // return results to the caller
  }
  public static void main(String[] args) {
    int x = 1, y = 2;
    trySwap(x, y);
    System.out.println("after trySwap: x=" + x + ", y=" + y); // 1,2
    int[] res = swap(x, y);
    x = res[0]; y = res[1];
    System.out.println("after swap:    x=" + x + ", y=" + y); // 2,1
  }
}

Kontrol af værdiparametre

Hurtig kontrol: Hvilket udsagn om Javas videregivelse af parametre er korrekt?

Besvar den i den interaktive lektion

Opsummering og næste trin

Opsummering: Du så forskellen på primitive typer og referencer, ændring og omtilordning, arrays som objekter, uforanderlighed og et sikkert mønster til bytning. Næste trin: statiske metoder og instansmetoder.

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 “Pass-by-value i Java” gratis?

Ja — hele teksten til “Pass-by-value i Java” 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 3 lektioner i alt.

Hvad lærer jeg i “Pass-by-value i Java”?

Forstå Javas pass-by-value: primitive typer kontra referencer, gentildeling kontra mutation samt faldgruber med arrays og uforanderlighed. 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 3.

Hvor lang tid tager lektionen “Pass-by-value i Java”?

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

← Tilbage til Java Academy