Panimula sa Mga Functional na Interface

Mangyaring huwag masyadong mag-troll, nagsisimula pa lang akong magsalin ng mga artikulo

Panimula sa Mga Functional na Interface - Mga Konseptong Muling Nilikha sa Java 8

Ang bawat developer ng Java sa mundo ay gumamit ng isa sa mga sumusunod na interface kahit isang beses: java.lang.Runnable, java.awt.event.ActionListener, java.util.Comparator, java.util.concurrent.Callable. Lahat sila ay may isang bagay na karaniwan, at iyon ay lahat sila ay may isang paraan lamang. Mayroong maraming iba pang mga ganoong interface sa JDK, pati na rin ang iba na nilikha ng mga developer ng Java. Ang mga interface na ito ay kilala rin bilang Single Abstract Method interfaces(SAM interfaces). Ang isa sa mga pinakasikat na paraan upang gamitin ang mga interface na ito ay ang paglikha ng mga hindi kilalang panloob na klase na gumagamit ng mga interface na ito, tulad ng sa sumusunod na halimbawa:

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

Sa Java 8, ang konsepto ng SAM ay muling nilikha at tinatawag na mga functional na interface. Maaaring katawanin ang mga ito gamit ang mga expression ng lambda, mga sanggunian ng pamamaraan, at mga tagapagtayo ng sanggunian. Ang isang bagong @FunctionalInterface annotation ay nilikha na ginagamit upang itapon ang mga error sa antas ng compiler kapag ang interface na iyong na-annotate ay hindi gumagana sa functional na antas. Tingnan natin ang isang simpleng functional na interface na may isang abstract na pamamaraan:

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

Ang isang interface ay maaari ding magdeklara ng mga abstract na pamamaraan mula sa isang class java.lang.Object, ngunit sa kasong ito ang interface ay maaari ding ideklarang functional:

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

Sa sandaling nagdagdag ka ng isa pang abstract na paraan sa interface, markahan ito ng IDE bilang mali tulad ng sa larawan: Ang isang interface ay maaaring magmana mula sa isa pang interface; kung ang interface ay nagmamana mula sa isang functional na interface at hindi naglalaman ng mga bagong abstract na pamamaraan, ang interface na ito ay gumagana din. Ngunit ang isang interface ay maaari lamang maglaman ng isang abstract na pamamaraan at maraming mga default na pamamaraan, at ito ay ituturing pa rin na gumagana.

@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...");
    }
}

Ang nangungunang halimbawa ay isang functional na interface pa rin. Ngayon tingnan natin kung paano natin magagamit ang mga expression ng lambda upang palitan ang isang hindi kilalang panloob na klase upang ipatupad ang mga functional na interface:

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

Ang magiging resulta ng programa ay ang mga sumusunod:

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

Kung sakaling gumagamit ka ng IDE na sumusuporta sa Java lambda expression syntax (Netbeans 8 Nightly builds) – Makakakuha ka ng pahiwatig kapag gumagamit ng mga anonymous na panloob na klase: Ito ay isang maikling panimula sa konsepto ng mga functional na interface sa Java 8 at kung paano sila maipapatupad gamit ang mga expression ng lambda.