Pengenalan kepada Antara Muka Berfungsi

Tolong jangan terlalu banyak troll, saya baru mula menterjemah artikel

Pengenalan kepada Antara Muka Berfungsi - Konsep Dicipta Semula dalam Java 8

Setiap pembangun Java di dunia telah menggunakan salah satu daripada antara muka berikut sekurang-kurangnya sekali: java.lang.Runnable, java.awt.event.ActionListener, java.util.Comparator, java.util.concurrent.Callable. Mereka semua mempunyai satu persamaan, dan itu adalah bahawa mereka semua hanya mempunyai satu kaedah. Terdapat banyak antara muka lain yang sedemikian dalam JDK, serta yang lain yang dicipta oleh pembangun Java. Antara muka ini juga dikenali sebagai Single Abstract Method interfaces(antara muka SAM). Salah satu cara paling popular untuk menggunakan antara muka ini ialah mencipta kelas dalaman tanpa nama yang menggunakan antara muka ini, seperti dalam 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();
    }
}

Dalam Java 8, konsep SAM dicipta semula dan dipanggil antara muka berfungsi. Mereka boleh diwakili menggunakan ungkapan lambda, rujukan kaedah dan pembina rujukan. Anotasi @FunctionalInterface baharu telah dibuat yang digunakan untuk membuang ralat pada peringkat pengkompil apabila antara muka yang anda anotasi tidak berfungsi pada tahap berfungsi. Mari kita lihat antara muka berfungsi mudah dengan satu kaedah abstrak:

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

Antara muka juga boleh mengisytiharkan kaedah abstrak dari kelas java.lang.Object, tetapi dalam kes ini antara muka juga boleh diisytiharkan berfungsi:

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

Sebaik sahaja anda telah menambah satu lagi kaedah abstrak pada antara muka, IDE akan menandakannya sebagai salah seperti dalam gambar: Antara muka boleh mewarisi daripada antara muka lain; jika antara muka mewarisi daripada antara muka berfungsi dan tidak mengandungi kaedah abstrak baharu, maka antara muka ini juga berfungsi. Tetapi antara muka hanya boleh mengandungi satu kaedah abstrak dan banyak kaedah lalai, dan ia masih akan dianggap berfungsi.

@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 merupakan antara muka yang berfungsi. Sekarang mari kita lihat bagaimana kita boleh menggunakan ungkapan lambda untuk menggantikan kelas dalaman tanpa nama untuk melaksanakan antara muka berfungsi:

/*
*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();
    }
}

Keputusan program adalah seperti berikut:

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

Sekiranya anda menggunakan IDE yang menyokong sintaks ungkapan lambda Java (binaan Netbeans 8 Nightly) – Anda mendapat petunjuk apabila menggunakan kelas dalaman tanpa nama: Ini adalah pengenalan ringkas kepada konsep antara muka berfungsi dalam Java 8 dan bagaimana ia boleh dilaksanakan menggunakan ungkapan lambda.