Java kata kunci ini

Pada CodeGym, pelajar diperkenalkan kepada Java kata kunci ini secara literal daripada pelajaran pertama. Lama kelamaan, maknanya menjadi jelas. Tetapi melihat ke belakang, ramai orang mungkin mengakui kepada diri mereka sendiri bahawa untuk masa yang lama mereka tidak dapat memahami Zen kata kunci ini. Artikel ini akan melabuhkan tirai menutupi rahsia kata kunci ini untuk sesiapa yang masih belum dapat berbuat demikian... Saya ada anda mendapat rujukan Java Schildt , kemudian pada halaman 171 anda boleh melihat bahawa kata kunci ini diperlukan untuk kaedah merujuk objek yang memanggilnya. Kita boleh menamatkan pelajaran dengan itu. Tetapi kita memerlukan spesifik. Sebagai peraturan, anda perlu menggunakan ini dalam dua kes:

1. Apabila pembolehubah contoh dan pembolehubah kaedah/pembina mempunyai nama yang sama;
2. Apabila anda perlu memanggil jenis pembina tertentu (contohnya, pembina lalai atau pembina parameter) daripada jenis pembina yang lain. Ini juga dipanggil panggilan pembina eksplisit.

Dan itu sahaja — hanya terdapat dua kes di mana kata kunci yang menakutkan ini digunakan. Sekarang mari kita lihat dua kes ini dalam contoh.

Contoh 1: Pembolehubah contoh dan pembolehubah kaedah mempunyai nama yang sama.

Katakan kita mempunyai kelas Manusia yang mentakrifkan medan nama: Mari buat penetap untuk pembolehubah nama (penetap berfungsi sepenuhnya — tiada tangkapan di sini):

class Human {
    String name;


    public void setName(String newName) {
        name = newName;
    }
}

Ambil perhatian bahawa kami menghantar String newName kepada kaedah setName setName Kami mengisytiharkan pembolehubah baharu dan boleh menamakannya apa sahaja yang kami mahu kerana ia akan kelihatan hanya dalam pendakap kerinting ({}) yang menyertakan kaedah setName . Ambil perhatian bahawa penetap mempunyai satu baris:

name = newName;

Di sini kami telah memperkenalkan pembolehubah baharu yang dipanggil newName dan memberikannya kepada pembolehubah nama sedia ada objek . Ramai pengaturcara mungkin merasa aneh untuk memperkenalkan pembolehubah dengan nama baharu apabila akhirnya kita bercakap tentang perkara yang sama. Iaitu, kita bercakap tentang medan nama dalam kelas Manusia . Itulah sebabnya pencipta Java memikirkan cara untuk menggunakan nama pembolehubah yang sama dengan mudah. Dengan kata lain, mengapa mempunyai dua nama untuk pembolehubah yang menunjukkan perkara yang sama. Dengan kata lain, kami ingin melakukan sesuatu seperti ini:

class Human {
    String name;


    public void setName(String name) {
        name = name;
    }
}

Tetapi di sini kita menghadapi masalah . Kami kini mempunyai dua pembolehubah dengan nama yang sama. Satu nama String tergolong dalam kelas Manusia , manakala nama String yang lain tergolong dalam kaedah setNamenya . Akibatnya, JVM tidak akan mengetahui pembolehubah yang anda rujuk apabila anda menulis baris berikut dalam penetap:

name = name;

Java menganggap anda maksudkan pembolehubah nama yang paling hampir , iaitu yang daripada kaedah setName : Jadi ternyata anda hanya memberikan pembolehubah nama kaedah kepada dirinya sendiri. Yang sudah tentu tidak masuk akal. Oleh itu, bahasa memerlukan beberapa cara untuk membezakan pembolehubah nama kelas Manusia daripada pembolehubah nama dalam kaedah setName . Masalah ini telah diselesaikan dengan memperkenalkan kata kunci ini , yang dalam kes ini menunjukkan bahawa anda berhasrat untuk merujuk pembolehubah yang dikaitkan dengan contoh kelas Manusia , bukan pembolehubah dalam kaedah: Dengan kata lain, inimerujuk kepada objek panggilan, seperti yang kami nyatakan pada permulaan artikel. Akibatnya, kaedah setName menetapkan nama orang pada objek yang dibuat. Di bawah ialah kod program tanpa menggunakan kata kunci ini . Kod mencipta objek Manusia dan memberikan nama kepadanya: Dan berikut ialah kod dengan kata kunci ini :

public class Solution {
    public static void main(String[] args) {
        Human human1 = new Human();
        human1.setName("Vinny");
        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, ini membolehkan kita mengelak daripada memperkenalkan pembolehubah baharu untuk menandakan perkara yang sama, menjadikan kod lebih bersih dan kurang berselerak dengan pembolehubah tambahan.

Contoh 2: Menggunakan ini untuk panggilan pembina eksplisit

Memanggil satu pembina daripada yang lain boleh berguna apabila anda mempunyai (cukup aneh) berbilang pembina dan anda tidak mahu pembina baharu menduplikasi kod permulaan yang sebelum ini ditulis dalam pembina yang berbeza. keliru? Ia tidak begitu menakutkan seperti yang kelihatan. Lihat kod di bawah. Ia mempunyai dua pembina untuk kelas Manusia :

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) {
        // Call the constructor with two parameters
        this(age, weight);
        // and then initialize the missing variable
        this.height = height;
    }
}

Di sini kami mula-mula menyediakan pembina dengan dua parameter: int age dan int weight . Katakan ia mempunyai dua baris kod:

this.age = age;
this.weight = weight;

Kemudian kami memutuskan untuk menambah pembina lain dengan tiga parameter, menambah ketinggian kepada parameter umur dan berat sedia ada. Anda boleh menulis pembina baharu seperti ini:

this.age = age;
this.weight = weight;
this.height = height;

Tetapi daripada mengulangi kod sedia ada dalam pembina ini, anda boleh menggunakan kata kunci ini untuk secara eksplisit memanggil pembina dengan dua parameter:

this(age, weight);
// and then initialize the missing variable:
this.height = height;

Seolah-olah kita berkata kepada pembina tiga parameter:

• panggil pembina lain ini yang mempunyai dua parameter
• dan kemudian tambah pembolehubah lain.

Itu sahaja =). Akhir sekali, kami perhatikan bahawa dalam Java kata kunci ini hanya digunakan dalam kaedah dan pembina. Tetapi ini dihantar secara tersirat kepada semua kaedah bukan statik (itu sebabnya ini sering dipanggil parameter tersirat) dan boleh digunakan untuk merujuk kepada objek yang dipanggil kaedah. Jangan takut dengan kata kunci ini, kerana ini tidak menakutkan.