Pambuka kanggo Antarmuka Fungsional

Aja banget troll, aku lagi miwiti nerjemahake artikel

Pengantar Antarmuka Fungsional - Konsep sing Digawe Ulang ing Jawa 8

Saben pangembang Java ing donya wis nggunakake salah siji saka antarmuka ing ngisor iki paling ora sapisan: java.lang.Runnable, java.awt.event.ActionListener, java.util.Comparator, java.util.concurrent.Callable. Kabeh padha duwe siji bab, lan iku kabeh duwe mung siji cara. Ana akeh antarmuka liyane ing JDK, uga liyane sing digawe dening pangembang Java. Antarmuka iki uga dikenal minangka Single Abstract Method interfaces(antarmuka SAM). Salah sawijining cara sing paling populer kanggo nggunakake antarmuka iki yaiku nggawe kelas internal anonim sing nggunakake antarmuka kasebut, kaya ing conto ing ngisor iki:

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

Ing Jawa 8, konsep SAM digawe maneh lan diarani antarmuka fungsional. Bisa diwakili nggunakake ekspresi lambda, referensi metode, lan konstruktor referensi. Anotasi @FunctionalInterface anyar wis digawe sing digunakake kanggo mbuwang kesalahan ing tingkat kompiler nalika antarmuka sing sampeyan anotasi ora bisa digunakake ing tingkat fungsional. Ayo goleki antarmuka fungsional sing prasaja kanthi siji cara abstrak:

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

Antarmuka uga bisa ngumumake metode abstrak saka kelas java.lang.Object, nanging ing kasus iki antarmuka uga bisa diumumake kanthi fungsional:

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

Sanalika sampeyan nambahake cara abstrak liyane menyang antarmuka, IDE bakal menehi tandha minangka salah kaya ing gambar: Antarmuka bisa diwenehi warisan saka antarmuka liyane; yen antarmuka warisan saka antarmuka fungsional lan ora ngemot metode abstrak anyar, antarmuka iki uga fungsional. Nanging antarmuka mung bisa ngemot siji cara abstrak lan akeh cara standar, lan isih bakal dianggep 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...");
    }
}

Conto ndhuwur isih antarmuka fungsional. Saiki ayo goleki carane nggunakake ekspresi lambda kanggo ngganti kelas njero anonim kanggo ngetrapake 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();
    }
}

Asil saka program bakal kaya ing ngisor iki:

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

Yen sampeyan nggunakake IDE sing ndhukung sintaks ekspresi lambda Java (Netbeans 8 Nightly builds) - Sampeyan entuk pitunjuk nalika nggunakake kelas internal anonim: Iki minangka introduksi singkat babagan konsep antarmuka fungsional ing Jawa 8 lan carane bisa dileksanakake. nggunakake ekspresi lambda.