Pada artikel ini, kita akan belajar 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. Sebagai contoh,
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 :
referensi ini = Main @ 23fc625e referensi objek = Main @ 23fc625e
Dalam contoh di atas, kami membuat sebuah objek bernama obj dari kelas Main. Kami kemudian mencetak referensi ke object obj dan thiskata kunci kelas.
Di sini, kita dapat melihat bahwa referensi dari kedua obj dan thissama. Artinya ini tidak lain adalah referensi ke objek saat ini.
Penggunaan Kata Kunci ini
Ada berbagai situasi di mana thiskata kunci biasanya 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 lingkup (lingkup kelas atau lingkup metode). Namun, variabel dan parameter instance mungkin memiliki nama yang sama. Sebagai contoh,
class MyClass ( // instance variable int age; // parameter MyClass(int age)( age = age; ) )
Pada program di atas, variabel instance dan parameter memiliki nama yang sama: usia. Di sini, compiler Java bingung karena ambiguitas nama.
Dalam situasi seperti itu, kami menggunakan kata kunci ini. Sebagai contoh,
Pertama, mari kita lihat contoh tanpa menggunakan thiskata 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 :
mc.age = 0
Dalam contoh di atas, kami telah mengirimkan 8sebagai nilai ke konstruktor. Namun, kami mendapatkan 0sebagai output. Ini karena compiler Java menjadi bingung karena adanya ambiguitas dalam nama antara instance variabel dan parameter.
Sekarang, mari kita tulis ulang kode di atas menggunakan thiskata 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 hasil yang diharapkan. Hal ini dikarenakan ketika konstruktor dipanggil, thisdi dalam konstruktor tersebut digantikan oleh objek objek yang disebut konstruktor. Oleh karena itu variabel usia diberi nilai 8.
Selain itu, jika nama parameter dan variabel instance berbeda, compiler 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 Getters dan Setter
Penggunaan umum lainnya dari thiskata kunci adalah dalam metode penyetel dan pengambil kelas. Sebagai contoh:
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 thiskata kunci:
- untuk menetapkan nilai di dalam metode penyetel
- untuk mengakses nilai di dalam metode pengambil
Menggunakan ini di Constructor Overloading
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, kami harus menggunakan thiskata kunci.
Di sini, kami menggunakan bentuk berbeda dari kata kunci ini. Artinya 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 thiskata kunci,
- untuk memanggil konstruktor
Complex(int i, int j)dari konstruktorComplex(int i) - untuk memanggil konstruktor
Complex(int i)dari konstruktorComplex()
Perhatikan garisnya,
System.out.println(c1);
Here, when we print the object c1, the object is converted into a string. In this process, the toString() is called. Since we override the toString() method inside our class, we get the output according to that method.
One of the huge advantages of this() is to reduce the amount of duplicate code. However, we should be always careful while using this().
This is because calling constructor from another constructor adds overhead and it is a slow process. Another huge advantage of using this() is to reduce the amount of duplicate code.
Note: Invoking one constructor from another constructor is called explicit constructor invocation.
Passing this as an Argument
We can use this keyword to pass the current object as an argument to a method. For example,
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 :
Sebelum meneruskan ini ke metode addTwo (): x = 1, y = -2 Setelah meneruskan ini ke metode addTwo (): x = 3, y = 0
Dalam contoh di atas, di dalam konstruktor ThisExample(), perhatikan barisnya,
add(this);
Di sini, kami memanggil add()metode dengan meneruskan ini sebagai argumen. Karena kata kunci ini berisi referensi ke objek objek kelas, kita dapat mengubah nilai x dan y di dalam add()metode.
