Java Academy · Pelajaran

Jenis Primitif berbanding Rujukan

Fahami perbezaan asas antara jenis primitif dengan jenis rujukan dalam Java.

Pelajaran 1 daripada 413 langkah

Jenis Primitif berbanding Rujukan ialah pelajaran Java Academy percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. 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 4 pelajaran.

Jenis Primitif berbanding Jenis Rujukan

Java mempunyai dua kategori asas jenis data: jenis primitif dan jenis rujukan. Memahami perbezaannya penting untuk menulis kod Java yang betul dan cekap.

Lapan Jenis Primitif

Java mempunyai tepat lapan jenis primitif:

byte (integer 8-bit)
short (integer 16-bit)
int (integer 32-bit)
long (integer 64-bit)
float (perpuluhan 32-bit)
double (perpuluhan 64-bit)
char (aksara Unicode 16-bit)
boolean (benar/palsu)

Jenis primitif menyimpan nilai terus dalam memori — tanpa overhed objek.

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

Jenis Rujukan

Jenis rujukan menyimpan alamat memori (rujukan) yang menunjuk kepada objek dalam timbunan. Ini termasuk:

Kelas (contohnya, String, Scanner)
Tatasusunan (contohnya, int[])
Antara muka
Enumerasi dan rekod

Pemboleh ubah tidak menyimpan objek tersebut — sebaliknya menyimpan penuding kepadanya.

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

Memori Tindanan berbanding Timbunan

Pemboleh ubah primitif disimpan pada tindanan — memori yang pantas dan berjangka hayat pendek, terikat pada panggilan kaedah.

Objek jenis rujukan berada dalam timbunan — memori yang lebih besar dan berjangka hayat panjang, yang diurus oleh kutipan sampah. Rujukan (alamat) itu sendiri berada pada tindanan.

// 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: Rujukan yang Tiada

Pemboleh ubah rujukan boleh diberikan nilai null, yang bermaksud pemboleh ubah itu tidak menunjuk kepada sebarang objek. Jenis primitif tidak boleh bernilai null — ia sentiasa mempunyai nilai.

Mengakses rujukan null menyebabkan NullPointerException (NPE) — salah satu ralat masa jalan Java yang paling lazim.

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

Semantik Penyalinan: Primitif

Apabila anda menetapkan pemboleh ubah primitif kepada pemboleh ubah lain, Java menyalin nilainya. Mengubah salah satunya tidak menjejaskan yang lain — kedua-duanya bebas sepenuhnya.

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

Semantik Penyalinan: Rujukan

Apabila anda menetapkan satu pemboleh ubah rujukan kepada pemboleh ubah lain, kedua-dua pemboleh ubah menunjuk kepada objek yang sama. Mengubah suai objek melalui satu rujukan dapat dilihat melalui rujukan yang lain.

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

Kelas Pembungkus: Membungkus Primitif

Setiap primitif mempunyai kelas pembungkus yang sepadan dalam java.lang:

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

Kelas pembungkus membolehkan anda menggunakan primitif sebagai objek — diperlukan untuk koleksi seperti 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

Perangkap Autopembungkusan

Autopembungkusan memang mudah, tetapi boleh menyebabkan pepijat yang sukar dikesan. Integer menyimpan nilai daripada -128 hingga 127 dalam cache — di luar julat itu, == membandingkan rujukan, bukannya nilai.

Sentiasa gunakan .equals() untuk membandingkan objek pembungkus.

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)

Menghantar kepada Kaedah: Hantar mengikut Nilai

Java sentiasa menggunakan penghantaran mengikut nilai. Untuk primitif, nilainya disalin. Untuk rujukan, rujukan (alamat) itu disalin — kedua-duanya menunjuk kepada objek yang sama, tetapi anda tidak boleh menetapkan semula pemboleh ubah pemanggil dari dalam kaedah.

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

Jadual Ringkasan Praktikal

Rujukan pantas yang membandingkan jenis primitif dan jenis rujukan:

Penyimpanan: primitif → nilai pada tindanan; rujukan → alamat pada tindanan + objek dalam timbunan
Nilai lalai: primitif → 0/false/\u0000; rujukan → null
Boleh bernilai null: primitif → Tidak; rujukan → Ya
Salinan penetapan: primitif → nilai; rujukan → alamat
Dalam koleksi: primitif memerlukan kelas pembungkus

Semakan Pantas

Apakah yang berlaku apabila anda menjalankan kod berikut?

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

Jawab dalam pelajaran interaktif

Rumusan: Jenis Primitif berbanding Jenis Rujukan

Perkara utama daripada pelajaran ini:

Java mempunyai 8 jenis primitif yang disimpan terus pada tindanan
Jenis rujukan menyimpan alamat objek dalam timbunan; pemboleh ubah menyimpan alamat tersebut
Primitif disalin mengikut nilai; rujukan disalin mengikut alamat
Pemboleh ubah rujukan boleh bernilai null; primitif tidak boleh
Kelas pembungkus (Integer, Double dan sebagainya) membungkus primitif sebagai objek
Java sentiasa menggunakan penghantaran mengikut nilai — termasuk ketika menghantar rujukan

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

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Jenis Primitif berbanding Rujukan” percuma?

Ya — teks penuh “Jenis Primitif berbanding Rujukan” 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 4 pelajaran.

Apakah yang akan saya pelajari dalam “Jenis Primitif berbanding Rujukan”?

Fahami perbezaan asas antara jenis primitif dengan jenis rujukan dalam Java. 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 4.

Berapa lamakah pelajaran “Jenis Primitif berbanding Rujukan” 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

← Kembali ke Java Academy