Jawa Kata Kunci ini

Java Kata Kunci ini

Dalam artikel ini, kita akan mempelajari tentang kata kunci ini di Java, bagaimana dan di mana menggunakannya dengan bantuan contoh.

Kata Kunci ini

Di Java, kata kunci ini digunakan untuk merujuk ke objek saat ini di dalam metode atau konstruktor. Misalnya,

class Main {
    int instVar;

    Main(int instVar){
        this.instVar = instVar;
        System.out.println("this reference = " + this);
    }

    public static void main(String[] args) {
        Main obj = new Main(8);
        System.out.println("object reference = " + obj);
    }
}

Keluaran :

this reference = Main@23fc625e
object reference = Main@23fc625e

Pada contoh di atas, kami membuat objek bernama obj dari kelas Utama . Kami kemudian mencetak referensi ke objek obj dan this kata kunci kelas.

Di sini, kita dapat melihat bahwa referensi dari kedua obj dan this adalah sama. Artinya ini tidak lain adalah referensi ke objek saat ini.

---

Penggunaan Kata Kunci ini

Ada berbagai situasi di mana this kata kunci yang umum digunakan.

Menggunakan ini untuk Nama Variabel Ambiguitas

Di Java, tidak diperbolehkan untuk mendeklarasikan dua atau lebih variabel yang memiliki nama yang sama di dalam sebuah ruang lingkup (ruang lingkup kelas atau ruang lingkup metode). Namun, variabel instan dan parameter mungkin memiliki nama yang sama. Misalnya,

class MyClass {
    // instance variable
    int age;

    // parameter
    MyClass(int age){
        age = age;
    }
}

Dalam program di atas, variabel instan dan parameter memiliki nama yang sama:usia. Di sini, kompiler Java bingung karena ambiguitas nama.

Dalam situasi seperti itu, kami menggunakan kata kunci ini. Misalnya,

Pertama, mari kita lihat contohnya tanpa menggunakan this kata kunci:

class Main {

    int age;
    Main(int age){
        age = age;
    }

    public static void main(String[] args) {
        Main obj = new Main(8);
        System.out.println("obj.age = " + obj.age);
    }
}

Keluaran :

obj.age = 0

Dalam contoh di atas, kami telah melewati 8 sebagai nilai bagi konstruktor. Namun, kami mendapatkan 0 sebagai keluaran. Ini karena kompiler Java menjadi bingung karena ambiguitas dalam nama antara instance variabel dan parameter.

Sekarang, mari kita tulis ulang kode di atas menggunakan this kata kunci.

class Main {

    int age;
    Main(int age){
        this.age = age;
    }

    public static void main(String[] args) {
        Main obj = new Main(8);
        System.out.println("obj.age = " + obj.age);
    }
}

Keluaran :

obj.age = 8

Sekarang, kita mendapatkan output yang diharapkan. Itu karena ketika konstruktor dipanggil, this di dalam konstruktor diganti dengan objek obj yang telah disebut konstruktor. Oleh karena itu usia variabel diberi nilai 8 .

Juga, jika nama parameter dan variabel instan berbeda, kompiler secara otomatis menambahkan kata kunci ini. Misalnya, kode:

class Main {
    int age;

    Main(int i) {
        age = i;
    }
}

setara dengan:

class Main {
    int age;

    Main(int i) {
        this.age = i;
    }
}

---

ini dengan Getter dan Setter

Penggunaan umum lainnya dari this kata kunci ada di metode setter dan getter dari sebuah kelas. Misalnya:

class Main {
   String name;

   // setter method
   void setName( String name ) {
       this.name = name;
   }

   // getter method
   String getName(){
       return this.name;
   }

   public static void main( String[] args ) {
       Main obj = new Main();

       // calling the setter and the getter method
       obj.setName("Toshiba");
       System.out.println("obj.name: "+obj.getName());
   }
}

Keluaran :

obj.name: Toshiba

Di sini, kami telah menggunakan this kata kunci:

• untuk menetapkan nilai di dalam metode penyetel
• untuk mengakses nilai di dalam metode pengambil

---

Menggunakan ini dalam Overloading Konstruktor

Saat bekerja dengan overloading konstruktor, kita mungkin harus memanggil satu konstruktor dari konstruktor lain. Dalam kasus seperti itu, kita tidak dapat memanggil konstruktor secara eksplisit. Sebagai gantinya, kita harus menggunakan this kata kunci.

Di sini, kami menggunakan bentuk yang berbeda dari kata kunci ini. Yaitu, this() . Mari kita ambil contoh,

class Complex {

    private int a, b;

    // constructor with 2 parameters
    private Complex( int i, int j ){
        this.a = i;
        this.b = j;
    }

    // constructor with single parameter
    private Complex(int i){
        // invokes the constructor with 2 parameters
        this(i, i); 
    }

    // constructor with no parameter
    private Complex(){
        // invokes the constructor with single parameter
        this(0);
    }

    @Override
    public String toString(){
        return this.a + " + " + this.b + "i";
    }

    public static void main( String[] args ) {
  
        // creating object of Complex class
        // calls the constructor with 2 parameters
        Complex c1 = new Complex(2, 3); 
    
        // calls the constructor with a single parameter
        Complex c2 = new Complex(3);

        // calls the constructor with no parameters
        Complex c3 = new Complex();

        // print objects
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
    }
}

Keluaran :

2 + 3i
3 + 3i
0 + 0i

Dalam contoh di atas, kami telah menggunakan this kata kunci,

• untuk memanggil konstruktor Complex(int i, int j) dari konstruktor Complex(int i)
• untuk memanggil konstruktor Complex(int i) dari konstruktor Complex()

Perhatikan barisnya,

System.out.println(c1);

Di sini, ketika kita mencetak objek c1 , objek diubah menjadi string. Dalam proses ini, toString() disebut. Karena kami mengganti toString() metode di dalam kelas kami, kami mendapatkan output sesuai dengan metode itu.

Salah satu keuntungan besar this() adalah untuk mengurangi jumlah duplikat kode. Namun, kita harus selalu berhati-hati saat menggunakan this() .

Ini karena memanggil konstruktor dari konstruktor lain menambah overhead dan ini adalah proses yang lambat. Keuntungan besar lainnya menggunakan this() adalah untuk mengurangi jumlah kode duplikat.

Catatan :Memanggil satu konstruktor dari konstruktor lain disebut pemanggilan konstruktor eksplisit.

---

Meneruskan ini sebagai Argumen

Kita bisa menggunakan this kata kunci untuk meneruskan objek saat ini sebagai argumen ke metode. Misalnya,

class ThisExample {
    // declare variables
    int x;
    int y;

    ThisExample(int x, int y) {
       // assign values of variables inside constructor
        this.x = x;
        this.y = y;

        // value of x and y before calling add()
        System.out.println("Before passing this to addTwo() method:");
        System.out.println("x = " + this.x + ", y = " + this.y);

        // call the add() method passing this as argument
        add(this);

        // value of x and y after calling add()
        System.out.println("After passing this to addTwo() method:");
        System.out.println("x = " + this.x + ", y = " + this.y);
    }

    void add(ThisExample o){
        o.x += 2;
        o.y += 2;
    }
}

class Main {
    public static void main( String[] args ) {
        ThisExample obj = new ThisExample(1, -2);
    }
}

Keluaran :

Before passing this to addTwo() method:
x = 1, y = -2
After passing this to addTwo() method:
x = 3, y = 0

Pada contoh di atas, di dalam konstruktor ThisExample() , perhatikan barisnya,

add(this);

Di sini, kami memanggil add() metode dengan melewatkan ini sebagai argumen. Karena kata kunci ini berisi referensi ke objek obj kelas, kita dapat mengubah nilai x dan y di dalam add() metode.