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

חלק מהיחידה תכנות מונחה עצמים במסלול ה-Java של Coddy. שיעור 39 מתוך 87.

ממשק פונקציונלי הוא ממשק שמכיל בדיוק מתודה מופשטת אחת. האילוץ הזה, של מתודה אחת בלבד, הופך ממשקים פונקציונליים למיוחדים, מכיוון שאפשר לממש אותם באמצעות ביטויי למבדה, וכך לכתוב קוד תמציתי יותר.

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

@FunctionalInterface
public interface Calculator {
    int calculate(int a, int b);
}

אפשר לממש ממשק פונקציונלי בדרך המסורתית באמצעות מחלקה, או בצורה תמציתית יותר באמצעות ביטוי למבדה:

// מימוש מסורתי
Calculator adder = new Calculator() {
    @Override
    public int calculate(int a, int b) {
        return a + b;
    }
};

// ביטוי למבדה (הרבה יותר קצר!)
Calculator adder = (a, b) -> a + b;

System.out.println(adder.calculate(5, 3));  // 8

לממשקים פונקציונליים עדיין יכולות להיות מתודות ברירת מחדל ומתודות סטטיות, מכיוון שהן אינן נחשבות לכלל המתודה האבסטרקטית היחידה. החבילה java.util.function של Java מספקת ממשקים פונקציונליים מובנים רבים כמו Predicate, Function ו־Consumer, שתיתקלו בהם לעיתים קרובות בעבודה עם זרמים ואוספים.

אתגר

קל

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

תארגנו את הקוד שלכם בשלושה קבצים:

StringTransformer.java: הגדירו ממשק פונקציונלי שמייצג כל פעולת שינוי של מחרוזת. סמנו אותו בהערה @FunctionalInterface כדי לוודא שהוא נשאר פונקציונלי. על הממשק שלכם להצהיר על מתודה מופשטת יחידה בשם transform שמקבלת String ומחזירה String.
TextProcessor.java: צרו מחלקה שמשתמשת בממשק הפונקציונלי שלכם כדי לעבד טקסט. צרו בה שדה שיחזיק StringTransformer ובנאי שיאתחל אותו. הוסיפו מתודה בשם process(String text) שמחילה את המתמיר על הטקסט הנתון ומחזירה את התוצאה. התכנון הזה מאפשר לכם להעביר כל התנהגות של שינוי דרך הבנאי.
Main.java: חברו את כל החלקים יחד על ידי יצירת פעולות שינוי שונות באמצעות ביטויי lambda. תקבלו שתי קלטים: מחרוזת טקסט וסוג פעולה (upper, lower או reverse).
בהתאם לסוג הפעולה, צרו TextProcessor עם ביטוי ה-lambda המתאים:
- upper: משנה את הטקסט לאותיות גדולות
- lower: משנה את הטקסט לאותיות קטנות
- reverse: הופך את סדר התווים בטקסט (רמז: השתמשו ב-StringBuilder)
לאחר מכן קראו ל-process() עם טקסט הקלט והדפיסו את התוצאה בפורמט הזה: Result: [transformed text]

תקבלו שתי קלטים: הטקסט שיש לשנות (String) וסוג הפעולה (String).

שימו לב איך אותה מחלקת TextProcessor יכולה לבצע פעולות שונות לחלוטין, בהתאם לביטוי ה-lambda שאתם מעבירים לה: זהו הכוח של ממשקים פונקציונליים!

נסו בעצמכם

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String text = scanner.nextLine();
        String operation = scanner.nextLine();
        
        TextProcessor processor;
        
        // TODO: בהתאם לסוג הפעולה, צרו TextProcessor עם ביטוי הלמבדה המתאים:
        // - "upper": ממיר את הטקסט לאותיות רישיות
        // - "lower": ממיר את הטקסט לאותיות קטנות
        // - "reverse": הופך את סדר התווים בטקסט (רמז: השתמשו ב-StringBuilder)
        
        // TODO: קראו ל-process() עם טקסט הקלט והדפיסו את התוצאה
        // פורמט הפלט: "Result: [transformed text]"
    }
}