Pengantar Antarmuka Fungsional

Tolong jangan terlalu banyak troll, saya baru mulai menerjemahkan artikel

Pengantar Antarmuka Fungsional - Konsep yang Dibuat Kembali di Java 8

Setiap pengembang Java di dunia telah menggunakan salah satu antarmuka berikut setidaknya satu kali: java.lang.Runnable, java.awt.event.ActionListener, java.util.Comparator, java.util.concurrent.Callable. Mereka semua mempunyai satu kesamaan, yaitu mereka semua hanya mempunyai satu metode. Ada banyak antarmuka serupa lainnya di JDK, serta antarmuka lain yang dibuat oleh pengembang Java. Antarmuka ini juga dikenal sebagai Single Abstract Method interfaces(antarmuka SAM). Salah satu cara paling populer untuk menggunakan antarmuka ini adalah dengan membuat kelas dalam anonim yang menggunakan antarmuka ini, seperti pada contoh berikut:

public class AnonymousInnerClassTest {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("A thread created and running...");
            }
        }).start();
    }
}

Di Java 8, konsep SAM dibuat ulang dan disebut antarmuka fungsional. Mereka dapat direpresentasikan menggunakan ekspresi lambda, referensi metode, dan konstruktor referensi. Anotasi @FunctionalInterface baru telah dibuat yang digunakan untuk memunculkan kesalahan pada tingkat kompiler ketika antarmuka yang Anda anotasi tidak berfungsi pada tingkat fungsional. Mari kita lihat antarmuka fungsional sederhana dengan satu metode abstrak:

@FunctionalInterface
public interface SimpleFunInterface {
    public void doWork();
}

Sebuah antarmuka juga dapat mendeklarasikan metode abstrak dari suatu kelas java.lang.Object, tetapi dalam hal ini antarmuka juga dapat dinyatakan fungsional:

@FunctionalInterface
public interface SimpleFuncInterface {
    public void doWork();
    public String toString();
    public Boolean equals(Object o);
}

Segera setelah Anda menambahkan metode abstrak lain ke antarmuka, IDE akan menandainya sebagai salah seperti pada gambar: Sebuah antarmuka dapat mewarisi dari antarmuka lain; jika antarmuka tersebut mewarisi dari antarmuka fungsional dan tidak berisi metode abstrak baru, maka antarmuka ini juga berfungsi. Namun sebuah antarmuka hanya dapat berisi satu metode abstrak dan banyak metode default, dan masih dianggap fungsional.

@FunctionalInterface
public interface ComplexFunctionalInterface extends SimpleFuncInterface {
    default public void doSomeWork() {
        System.out.println("Doing some work in interface impl...");
    }
    default public void doSomeWork() {
        System.out.println("Doing some other work in interface impl...");
    }
}

Contoh teratas masih berupa antarmuka fungsional. Sekarang mari kita lihat bagaimana kita dapat menggunakan ekspresi lambda untuk menggantikan inner class anonim untuk mengimplementasikan antarmuka fungsional:

/*
*Implementation the interface by creating an
*anonymoous inner class versus using
*lambda expression.
*/
public class SimpleFunInterfaceTest {
    public static void main(String[] args) {
        carryOutWork(new SimpleFunInterface() {
            @Override
            public void doWork() {
                System.out.println("Do work in SimpleFun impl...");
            }
        });
        carryOutWork(() -> System.out.println("Do work in lambda exp impl..."));
    }
    public static void carryOutWork(SimpleFuncInterface sfi) {
        sfi.work();
    }
}

Hasil dari program ini adalah sebagai berikut:

Do work in SimpleFun impl...
Do work in lambda exp impl...

Jika Anda menggunakan IDE yang mendukung sintaks ekspresi lambda Java (Netbeans 8 Nightly build) - Anda mendapatkan petunjuk saat menggunakan kelas dalam anonim: Ini adalah pengenalan singkat tentang konsep antarmuka fungsional di Java 8 dan bagaimana penerapannya menggunakan ekspresi lambda.