Hantaran Mengikut Nilai dalam Java
Fahami hantaran mengikut nilai dalam Java: primitif berbanding rujukan, penetapan semula berbanding mutasi, tatasusunan dan perangkap ketakbolehubahan.
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.
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
- Hantaran Mengikut Nilai dalam Java
- Kaedah Static berbanding Instance
- Pecahan Kaedah dan Kod Kemas