Java Academy · Pelajaran

Hantaran Mengikut Nilai dalam Java

Fahami hantaran mengikut nilai dalam Java: primitif berbanding rujukan, penetapan semula berbanding mutasi, tatasusunan dan perangkap ketakbolehubahan.

Pelajaran 1 daripada 38 langkah

Hantaran Mengikut Nilai dalam Java ialah pelajaran Java Academy percuma di CoddyKit. Ini ialah pelajaran 1 daripada 3. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Java Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Java Academy merangkumi sejumlah 3 pelajaran.

Gambaran Keseluruhan Penghantaran Mengikut Nilai

Matlamat: Pelajari cara Java menghantar parameter. Bandingkan jenis primitif dengan rujukan, penetapan semula dengan mutasi, tatasusunan dan ketidakbolehubahan.

Salinan Primitif

Jenis primitif dihantar mengikut nilai: kaedah yang dipanggil menerima salinan. Menetapkan semula parameter tidak mengubah pemboleh ubah pemanggil.

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

Rujukan: Mutasi berbanding Penetapan Semula

Bagi objek, rujukan disalin. Mengubah objek melaluinya memberi kesan kepada objek pemanggil; menetapkan semula parameter tidak memberi kesan sedemikian.

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

Tatasusunan: Mutasi berbanding Penetapan Semula

Tatasusunan ialah objek. Lakukan mutasi untuk memberi kesan kepada pemanggil; menetapkan semula parameter tidak menggantikan tatasusunan pemanggil.

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

Tidak Boleh Diubah berbanding Boleh Diubah

String tidak boleh diubah (memulangkan objek baharu); StringBuilder boleh diubah (mengubah tika yang sama).

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

Tukar dengan Betul

Oleh sebab parameter ialah salinan, menukar primitif di dalam kaedah tidak memberi kesan kepada pemanggil. Pulangkan nilai baharu (atau objek pemegang).

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

Semakan Penghantaran Mengikut Nilai

Semakan ringkas: Pernyataan manakah tentang penghantaran parameter Java yang betul?

Ringkasan & Seterusnya

Ringkasan: Anda melihat perbezaan antara primitif dan rujukan, mutasi dan penetapan semula, tatasusunan sebagai objek, ketidakbolehubahan serta corak pertukaran yang selamat. Seterusnya: Kaedah Statik berbanding Instans.

Percuma untuk bermula

Pelajari Java dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus
104
Pelajaran
374

Soalan Lazim

Adakah pelajaran “Hantaran Mengikut Nilai dalam Java” percuma?

Ya — teks penuh “Hantaran Mengikut Nilai dalam Java” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Java Academy, tingkat taraf kepada CoddyKit PRO. Kursus Java Academy merangkumi sejumlah 3 pelajaran.

Apakah yang akan saya pelajari dalam “Hantaran Mengikut Nilai dalam Java”?

Fahami hantaran mengikut nilai dalam Java: primitif berbanding rujukan, penetapan semula berbanding mutasi, tatasusunan dan perangkap ketakbolehubahan. Anda berlatih Java Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Java Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Java Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 3.

Berapa lamakah pelajaran “Hantaran Mengikut Nilai dalam Java” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Java Academy ini?

Ya. Setiap pelajaran Java Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

  1. Hantaran Mengikut Nilai dalam Java
  2. Kaedah Static berbanding Instance
  3. Pecahan Kaedah dan Kod Kemas
← Kembali ke Java Academy