Apa yang kamu pikirkan saat mendengar kata anonymous?
“Sekelompok hacker yang bersembunyi di balik topeng”
Haha 
, bukan ini yang akan kita bahas.
, bukan ini yang akan kita bahas.
Pada tutorial ini, kita akan belajar tentang anonymous class di Java. Mulai dari pengenalan dan alasan mengapa harus menggunakan class anonymous, hingga contoh programnya.
Class ini mungkin jarang kamu gunakan, atau mungkin sudah pernah kamu gunakan tapi tak sadar itu adalah anonymous class.
Karena itu, mari kita bahas…
Apa itu Class Anonymous?
Class Anonymous adalah class yang tidak memiliki nama. Biasanya dibuat hanya untuk sekali pakai saja. Pada dasarnya class anonymous sama seperti class biasa. 1
Yang membedakan adalah tujuan ia dibuat.
Biasanya class anonymous dibuat untuk mengimplementasikan interface dan class abstrak secara langsung.
Class Anonymous mulai ditambahkan pada JDK versi 8. Jadi, buat kamu yang menggunakan JDK versi di bawah 8, maka class anonymous tidak akan bisa digunakan di sana.
Mengapa Harus Menggunakan Class Anonymous?
Anonymous class biasanya kita butuhkan saat tidak ingin membuat implementasi dari interface dan class abstrak dalam file Java yang berbeda.
Kita ingin.. implementasinya langsung di dalam kode yang sedang ditulis.
Misalnya gini:
(kita pakai contoh kasus)
Kita mau pakai sebuah tombol dan tombol tersebut punya interfece bernama
Clickable yang akan meng-handle bagaimana tombol itu diklik.// ini interface yang akan menangani klik pada tombol
interface Clickable {
void onClick();
void onHover();
}
// dan ini class Tombol
class Button {
void setClickAction(Clickable event){
event.onClick();
}
}
Biasanya kita akan melakukan implementasi seperti ini:
class SubmitPost implements Clickable {
// kode implementasi di sini
}
Lalu membuat objek tombol pada main method:
Button btn = new Button();
Clickable submitAction = new SubmitPost();
btn.setClickAction(submitAction);
Nah ini sebenarnya bisa kita buat lebih sederhana dengan Class Anonymous.
Button btn = new Button();
Clickable submitAction = new SubmitPost();
// menggunakan class anonymous untuk implementasi interface
btn.setClickAction(new Clickable(){
// kode implementasi di sini
});
Jadinya kita tidak perlu lagi membuat class
SubmitPost atau implementasi dari interface Clickable, karena sudah dibuat dengan class anonymous.
Sudah paham kan mengapa harus pakai class anonymous?
Biasanya kamu akan menemui kasus ini saat ngoding Android dan Java FX.
Baik, kalau begitu mari kita bahas lebih dalam tentang cara membuat dan menggunakan class anonymous.
Cara Membuat Class Anonymous
Class anounymous bersifat seperti ekspresi, ia dapat dibuat seperti membuat variabel.
Berikut ini cara membuat class anonymous:
Tungu dulu!
Tadi katanya class anonymous itu tidak memiliki nama..
Tapi kok ini ada nama?
Class anonymous memang tidak memiliki nama, namun dalam pembuatannya ia akan menggunakan nama dari Interface atau class abstrak yang ia implementasikan.
Kalau nggak begitu, terus bagaimana kita tahu interface atau class abstrak yang mana yang akan dia implementasikan.
Class anonymous dapat kita buat di beberapa tempat:
- Fields (pada properti)
Contoh:
- Di dalam method (parameter dan body)
Contoh:
- Instance initializers (seperti gambar di atas)
Contoh:
- Local classes (di dalam inner class)
Contoh:
Oh iya, class anonymous tidak boleh memiliki konstruktor.
Oke, sekrang mari kita coba contohnya di dalam program.
Contoh Program dengan Class Anonymous
Silahkan buka Netbeans, lalu buatlah proyek baru dengan nama
ClassAnonymous.
Setelah itu, buat sebuah interface baru pada pacakage
<default package> dengan nama Clickable dan isi kodenya seperti ini:interface Clickable {
void onClick();
}
Setelah itu, buatlah class
Button dengan isi seperti ini:public class Button {
private Clickable action;
void setClickAction(Clickable action){
this.action = action;
}
void doClick(){
action.onClick();
}
}
Terakhir, buatlah class
Main dengan isi seperti ini:public class Main {
public static void main(String[] args) {
Button btn = new Button();
// membuat class anonymous untuk implementasi interface
btn.setClickAction(new Clickable() {
@Override
public void onClick() {
System.out.println("Tombol sudah diklik!");
System.out.println("Yay!");
}
});
// mencoba klik tombol
btn.doClick();
}
}
Semuanya sudah siap, sekarang coba jalankan programnya.
Maka hasilnya:
Akses Variabel di Anonymous Class
Salah satu keuntungan saat kita menggunakan anonymous class adalah bisa mengakses variabel yang ada di dalam class tempat class anonymous itu dibaut.
Contoh, sekarang coba ubah kode yang ada di class Main menjadi seperti ini:
public class Main {
// membuat variabel di dalam class
static String title = "Tutorial Anonymous Class";
public static void main(String[] args) {
// membuat variabel di dalam method main
String name = "Petani Kode";
Button btn = new Button();
// membuat class anonymous untuk implemen interface
btn.setClickAction(new Clickable() {
// membuat variabel di dalam class anonymous
String message = "belajar Anonymous Class di Java";
@Override
public void onClick() {
System.out.println("Tombol sudah diklik!");
System.out.println("Yay!");
// mengakses variabel
System.out.println("Hello " + name);
System.out.println(title);
System.out.println(message);
}
});
// mencoba klik tombol
btn.doClick();
}
}
Hasilnya:
Semua variabel yang kita buat bisa diakses dari dalam anonymous class. Hebat kan!
Tapi class anonymous juga punya batasan, yakni kita tidak bisa mendeklarasikan member interface dan variabel static di dalamnya.
Menggunakan Anonymous Objek
Kalau ada class anonymous, pasti juga akan ada objek anonymous.
Objek anonymous adalah objek yang tak memiliki nama dan dia juga biasanya digunakan hanya untuk sekali pakai saja.
Sebenarnya pada contoh di atas, kita sudah menggunakan objek anonymous sebagap parameter pada method
setActionClick().// jika tidak menggunakan anonymous objek
// maka kita harus bikin instance baru dari anonymous class
Clickable clickAction = new Clickable() {
// kode implementasi di sini
}
// baru setelah itu dipakai menjadi partameter
btn.setClickAction(clickAction);
// Tapi jika menggunakan anonymous objek,
// kita tak perlu bikin objek baru.
// langsung saja ditulis seperti ini
btn.setClickAction(new Clickable(){
// kode implementasi di sini
});
Kita juga dapat menggunakan class anonymous secara langsung tanpa harus membuat objek baru.
Contohnya:
interface Talkable{
void sayHello();
}
// implementasi dan langsung digunakan
new Talkable(){
@override
void sayHello(){
System.out.println("Hello World!");
}
}.sayHello();
// ^ karena ini anonymous objek,
// jadi kita bisa langsung panggil methodnya
Jadi dengan kata kunci
new, kita akan bisa membuat anonymous objek.
Oh iya, anonymous objek tidak hanya untuk class anonymous saja. Dia juga bisa dipakai untuk class biasa.
Contoh:
// membuat class biasa
class Hello {
void saySomething(){
System.out.println("Something..");
}
}
// menggunakan class Hello untuk membuat anonymous objek
new Hello().saySomething();
Apa Selanjutnya?
Menurut saya, class anonymous sangat membantu saat kita butuh implementasi langsung dari interface dan class abstrak. Ini akan menghemat waktu kita. Karena tidak perlu bikin class baru lagi secara terpisah.
Selain itu, kode program kita juga akan terlihat lebih bersih dan mudah terbaca.
Terimakasih class anonymous 
…
…
Selenjutnya silahkan coba juga latihan mengimplementasikan class abstrak dengan class anonymous.
Oh iya, Java punya satu lagi hal yang berbau ‘anonymous’, yakni anonymous function atau dikenal juga dengan lambda expression.
Komentar
Posting Komentar