Di JavaRush, pelajar diperkenalkan kepada kata kunci secara literal daripada kuliah pertama
dan ternyata anda hanya memberikan nilai kepada pembolehubah
Iaitu,
Dan di bawah adalah kod program dengan kata kunci
this
. Dan dari masa ke masa ia menjadi jelas apa maksudnya. Tetapi ramai, melihat ke belakang, mungkin akan dengan jujur mengatakan kepada diri mereka sendiri bahawa untuk masa yang lama mereka tidak dapat menyedari zen kata kunci ini. Dalam artikel ini kami membuka tabir rahsia tentang menggunakan kata kunci this
bagi mereka yang masih tidak dapat memahaminya... Selamat datang! Jika anda mengambil buku rujukan Java Schildt , pada halaman 171 anda akan membaca bahawa kata kunci this
diperlukan supaya kaedah boleh merujuk objek yang memanggilnya. Ini sebenarnya boleh menjadi penghujungnya. Tetapi kita memerlukan spesifik. Sebagai peraturan, this
ia harus digunakan dalam dua kes:
- Apabila pembolehubah contoh kelas dan pembolehubah kaedah/pembina mempunyai nama yang sama;
- Apabila anda perlu memanggil pembina satu jenis (contohnya, pembina lalai atau berparameter) daripada yang lain. Ini juga dipanggil panggilan pembina eksplisit.
Contoh satu - pembolehubah contoh dan pembolehubah kaedah mempunyai nama yang sama
Katakan kita mempunyai kelasHuman
yang mana medan "nama" ditakrifkan: Mari name
buat penetap untuk pembolehubah (penetap agak berfungsi dan tiada muslihat di sini): Sila ambil perhatian bahawa kita menghantar pembolehubah kepada kaedah (penetap ) . Kami memperkenalkan pembolehubah baharu dan (secara amnya) boleh memanggilnya apa sahaja yang kami mahu kerana ia hanya boleh dilihat dalam {curly braces} kaedah . Perhatikan bahawa terdapat satu baris dalam penetap: setName
String newName
setName
name = newName;
Iaitu, sebenarnya, kami memperkenalkan pembolehubah baharu newName
dan memberikannya kepada pembolehubah yang sudah sedia ada dalam kelas name
. Ramai pengaturcara menganggap pelik untuk memperkenalkan pembolehubah dengan nama baru jika pada akhirnya kita bercakap tentang perkara yang sama. Mengenai nama dalam kelas Human
. Oleh itu, pembangun bahasa berfikir untuk menjadikannya mudah untuk menggunakan satu nama pembolehubah. Dengan kata lain, mengapa mempunyai dua nama untuk pembolehubah yang bermaksud perkara yang sama. Iaitu, saya ingin melakukan sesuatu seperti ini: Tetapi dalam kes ini masalah timbul . Kami kini mempunyai dua pembolehubah yang dinamakan sama. Satu String name
tergolong dalam kelas Human
, dan satu lagi String name
dalam kaedahnya setName
. Oleh itu, mesin Java tidak tahu pembolehubah mana yang anda maksudkan apabila anda menulis rentetan dalam penetap:
name = name;
Java mengambil yang paling dekat - name
dari kaedah setName
:
name
daripada kaedah ini, kepadanya. Yang sudah tentu tidak masuk akal. Oleh itu, beberapa cara diperlukan untuk membezakan pembolehubah name
daripada kelas Human
daripada pembolehubah name
daripada kaedah setName
. Untuk menyelesaikan masalah ini, kata kunci telah diperkenalkan this
, yang dalam kes ini akan menunjukkan bahawa adalah perlu untuk memanggil pembolehubah bukan kaedah, tetapi daripada sebuah kelas Human
:
this
ia akan merujuk kepada objek panggilan, seperti yang dikatakan pada permulaan artikel. Akibatnya, nama orang itu setName
akan ditetapkan melalui penetap kepada objek yang dibuat. Di bawah ialah kod tanpa menggunakan kata kunci this
. Kod mencipta objek kelas Human
dan memberikannya nama:
this
:
public class Solution{
public static void main(String[] args) {
Human human1 = new Human();
human1.setName("Volodya");
human1.print();
}
}
class Human{
String name;
public String getName() {
return name;
}
public void setName(String name){
this.name = name;
}
void print(){
System.out.println(name);
}
}
Oleh itu, ia this
mengelak daripada memperkenalkan pembolehubah baharu untuk menandakan perkara yang sama, yang menjadikan kod kurang "terbeban" dengan pembolehubah tambahan.
Contoh Dua - Menggunakan ini untuk memanggil pembina secara eksplisit
Memanggil satu pembina daripada yang lain boleh berguna apabila anda (cukup aneh) mempunyai beberapa pembina dan anda tidak mahu menulis semula kod permulaan yang diberikan sebelum ini dalam pembina dalam pembina baharu. keliru? Semuanya tidak seram seperti yang disangka. Lihat kod di bawah, ia mempunyai dua pembina kelasHuman
:
class Human{
int age;
int weight;
int height;
Human(int age, int weight){
this.age = age;
this.weight = weight;
}
Human(int age, int weight, int height){
//you call the constructor with two parameters
this(age, weight);
//and add the missing variable
this.height = height;
}
}
Di sini kita mula-mula mempunyai pembina dua parameter yang menerima int age
dan int weight
. Katakan kita menulis dua baris kod di dalamnya:
this.age = age;
this.weight = weight;
dan kemudian mereka memutuskan untuk menambah pembina lain, dengan tiga parameter, yang, sebagai tambahan kepada umur dan berat, juga mengambil ketinggian. Dalam pembina baharu anda boleh menulis ini:
this.age = age;
this.weight = weight;
this.height = height;
Tetapi daripada mengulangi kod yang telah anda tulis dalam pembina ini, anda boleh menggunakan kata kunci untuk this
memanggil pembina secara eksplisit dengan dua parameter:
this(age, weight);
// and add the missing variable:
this.height = height;
Jadi anda agak memberitahu pembina dengan tiga parameter:
- panggil pembina ini, yang mempunyai dua parameter.
- dan tambah pembolehubah yang hilang.
this
dihantar kepada semua kaedah kecuali kaedah statik (oleh itu mengapa ia this
sering dipanggil parameter tersirat) dan boleh digunakan untuk merujuk kepada objek yang dipanggil kaedah. Tidak perlu takut dengan kata kunci ini, kerana This
ia tidak menakutkan.
GO TO FULL VERSION