מבוא לממשקים פונקציונליים

בבקשה אל תטרל יותר מדי, אני רק מתחיל לתרגם מאמרים

מבוא לממשקים פונקציונליים - מושגים שנוצרו מחדש ב-Java 8

כל מפתח Java בעולם השתמש באחד מהממשקים הבאים לפחות פעם אחת: java.lang.Runnable, java.awt.event.ActionListener, java.util.Comparator, java.util.concurrent.Callable. לכולם יש דבר אחד במשותף, וזה שלכולם יש רק שיטה אחת. ישנם ממשקים רבים אחרים כאלה ב-JDK, כמו גם אחרים שנוצרו על ידי מפתחי Java. ממשקים אלו ידועים גם בשם Single Abstract Method interfaces(ממשקי SAM). אחת הדרכים הפופולריות ביותר להשתמש בממשקים אלה היא ליצור מחלקות פנימיות אנונימיות המשתמשות בממשקים אלה, כמו בדוגמה הבאה:

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

ב-Java 8, מושג ה-SAM נוצר מחדש ונקרא ממשקים פונקציונליים. ניתן לייצג אותם באמצעות ביטויי למבדה, הפניות לשיטה ובניי הפניות. נוצרה הערת @FunctionalInterface חדשה המשמשת לזריקת שגיאות ברמת המהדר כאשר הממשק שציינת לא עובד ברמה הפונקציונלית. בואו נסתכל על ממשק פונקציונלי פשוט עם שיטה מופשטת אחת:

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

ממשק יכול גם להכריז על מתודות מופשטות ממחלקה java.lang.Object, אבל במקרה זה ניתן להכריז על הממשק גם כפונקציונלי:

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

ברגע שהוספתם עוד שיטה מופשטת לממשק, ה-IDE יסמן אותה כשגויה כמו בתמונה: ממשק יכול לרשת מממשק אחר; אם הממשק יורש מממשק פונקציונלי ואינו מכיל שיטות מופשטות חדשות, אז גם ממשק זה פונקציונלי. אבל ממשק יכול להכיל רק שיטה מופשטת אחת ושיטות ברירת מחדל רבות, והוא עדיין ייחשב פונקציונלי.

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

הדוגמה העליונה היא עדיין ממשק פונקציונלי. כעת נסתכל כיצד אנו יכולים להשתמש בביטויי למבדה כדי להחליף מחלקה פנימית אנונימית כדי ליישם ממשקים פונקציונליים:

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

התוצאה של התוכנית תהיה כדלקמן:

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

במקרה שאתה משתמש ב-IDE התומך בתחביר ביטוי Java lambda (בניית Netbeans 8 Nightly) - אתה מקבל רמז בעת שימוש במחלקות פנימיות אנונימיות: זה היה הקדמה קצרה למושג ממשקים פונקציונליים ב-Java 8 וכיצד ניתן ליישם אותם שימוש בביטויי למבדה.