Java Academy · Lektion

Värdeöverföring i Java

Förstå Javas värdeöverföring: primitiva typer kontra referenser, omtilldelning kontra mutering, arrayer och fallgropar med oföränderlighet.

Lektion 1 av 38 steg

Värdeöverföring i Java är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 1 av 3. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Java Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Java Academy innehåller totalt 3 lektioner.

Översikt över pass-by-value

Mål: Lär er hur Java skickar parametrar. Jämför primitiva typer med referenser, omtilldelning med mutering, arrayer och oföränderlighet.

Primitiver kopieras

Primitiva typer skickas med värde: den anropade metoden får en kopia. Att tilldela parametern ett nytt värde ändrar inte anroparens 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
  }
}

Referenser: mutera kontra tilldela om

För objekt kopieras referensen. Om ni muterar objektet via referensen påverkas anroparens objekt; att tilldela parametern ett nytt objekt gör det inte.

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
  }
}

Arrayer: mutera kontra tilldela om

Arrayer är objekt. Mutera arrayen för att påverka anroparen; att tilldela parametern en ny array ersätter inte anroparens 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
  }
}

Oföränderlig kontra förändringsbar

String är oföränderlig och returnerar nya objekt; StringBuilder är förändringsbar och ändrar samma 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 värden korrekt

Eftersom parametrar är kopior påverkar ett byte av primitiva värden inuti en metod inte anroparen. Returnera nya värden eller använd ett behållarobjekt.

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
  }
}

Kontroll av pass-by-value

Snabb kontroll: Vilket påstående om hur Java skickar parametrar är korrekt?

Repetition och nästa steg

Repetition: Ni såg skillnaden mellan primitiva typer och referenser, mutering och omtilldelning, arrayer som objekt, oföränderlighet samt ett säkert mönster för att byta värden. Nästa steg: statiska metoder kontra instansmetoder.

Gratis att börja

Lär dig Java med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser
104
Lektioner
374

Vanliga frågor

Är lektionen ”Värdeöverföring i Java” gratis?

Ja – hela texten till ”Värdeöverföring i Java” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Java Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Java Academy innehåller totalt 3 lektioner.

Vad lär jag mig i ”Värdeöverföring i Java”?

Förstå Javas värdeöverföring: primitiva typer kontra referenser, omtilldelning kontra mutering, arrayer och fallgropar med oföränderlighet. Ni övar på Java Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Java Academy?

Du behöver inga förkunskaper. Utbildningen i Java Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 3.

Hur lång tid tar lektionen ”Värdeöverföring i Java”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Java Academy-lektionen?

Ja. Varje Java Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

  1. Värdeöverföring i Java
  2. Statiska metoder kontra instansmetoder
  3. Metodnedbrytning och ren kod
← Tillbaka till Java Academy