Tutorial Java OOP: Mengenal Class Anonymous di Java

Apa yang kamu pikirkan saat mendengar kata anonymous? Sekelompok hacker yang bersembunyi di balik topeng?

Haha 😄, 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. ¹

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 seperti ini:

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 coding 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, tetapi kok ini ada nama?

Class anonymous memang tidak memiliki nama, tetapi dalam pembuatannya ia akan menggunakan nama dari Interface atau class abstrak yang ia implementasikan.

Kalau tidak seperti itu, lalu 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

Silakan 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 dibuat.

Contohnya, 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? Sayangnya, 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();

Baca juga: Tutorial Java OOP: Mengenal Lambda Expression untuk Membuat Fungsi Anonymous di Java | Apa Saja yang Baru di Java 11? | Cara Install Netbeans 10 di Linux