author Ahmad Muhardian

Tutorial Java OOP: Mengenal Class Anonymous di Java

Apa yang kamu pikirkan saat mendengar kata anonymous?

“Sekelompok hacker yang bersembunyi di balik topeng”

Anonymous Indonesia

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. 1

Yang membedakan adalah tujuan ia dibuat.

Biasanya class anonymous dibuat untuk mengimplementasikan interface dan class abstrak secara langsung.

Mengenal Class Anonymous di Java

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 interface 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 anonymous bersifat seperti ekspresi, ia dapat dibuat seperti membuat variabel.

Berikut ini cara membuat class anonymous:

Membuat class anonymous di Java

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:
    class Sesuatu {
  String nama;
  int umur;
  Anonymous anonField = new Anonymous(){
    // implementasi di sini
  }
}

  • Di dalam method (parameter dan body)

    Contoh:
    class Sesuatu {
  String nama;
  int umur;
  void sayHello(new Anonymous(){
      // kode implementasi di sini
  });
  void sayThanks(){
    new Anonymous(){
      // kode implementasi di sini
    }
  }
}

  • Instance initializers (seperti gambar di atas)

    Contoh:
    class Sesuatu {
  private Anonymous anonobj;
  void Susuatu(){
    this.anonobj = new Anonymous(){
      // kode implementasi di sini
    }
  }
}

  • Local classes (di dalam inner class)

    Contoh:
    class Sesuatu {
  class Lokal {
    void doSomething(){
      new Anonymous(){
        // kode implementasi di sini
      }
    }
  }
}

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.

Membuat proyek baru di Netbeans

Setelah itu, buat sebuah interface baru pada package <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:

Hasil contoh program anonymous class

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.

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:

Hasil contoh program anonymous class

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.

Static variabel di anonymous class

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 sebagai 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 parameter
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 method-nya

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.

Terima kasih class anonymous 🙏…

Selanjutnya silakan 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.

Ini akan dibahas pada:

📖 Tutorial Java yang lainnya, silakan cek di List Tutorial Java

  1. Java Documentation - Anonymous Classes ↩︎