Funktionale Interfaces

Teil des Abschnitts Objektorientierte Programmierung der Java-Journey von Coddy. Lektion 39 von 87.

Ein funktionales Interface ist ein Interface, das genau eine abstrakte Methode enthält. Diese Einschränkung auf eine einzige Methode macht funktionale Interfaces besonders, da sie mithilfe von Lambda-Ausdrücken implementiert werden können und dadurch einen prägnanteren Programmierstil ermöglichen.

Java stellt die Annotation @FunctionalInterface bereit, um eine Schnittstelle ausdrücklich als funktional zu kennzeichnen. Obwohl diese Annotation optional ist, hilft sie dem Compiler, Fehler zu erkennen, wenn du versehentlich eine zweite abstrakte Methode hinzufügst:

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

Du kannst ein funktionales Interface auf herkömmliche Weise mit einer Klasse oder kürzer mit einem Lambda-Ausdruck implementieren:

// Traditionelle Implementierung
Calculator adder = new Calculator() {
    @Override
    public int calculate(int a, int b) {
        return a + b;
    }
};

// Lambda-Ausdruck (viel kürzer!)
Calculator adder = (a, b) -> a + b;

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

Funktionale Schnittstellen können weiterhin Standardmethoden und statische Methoden enthalten, da diese nicht auf die Regel für eine einzige abstrakte Methode angerechnet werden. Das Java-Paket java.util.function stellt viele integrierte funktionale Schnittstellen wie Predicate, Function und Consumer bereit, denen du bei der Arbeit mit Streams und Collections häufig begegnen wirst.

Aufgabe

Einfach

Erstellen wir ein String-Transformationssystem mithilfe funktionaler Schnittstellen und Lambda-Ausdrücken. Du erstellst einen flexiblen Textprozessor, der verschiedene Transformationen auf Strings anwenden kann – alles gesteuert durch eine einzige funktionale Schnittstelle.

Du organisierst deinen Code über drei Dateien:

StringTransformer.java: Definiere eine funktionale Schnittstelle, die jede String-Transformationsoperation repräsentiert. Kennzeichne sie mit der Annotation @FunctionalInterface, um sicherzustellen, dass sie funktional bleibt. Deine Schnittstelle sollte eine einzelne abstrakte Methode namens transform deklarieren, die einen String entgegennimmt und einen String zurückgibt.
TextProcessor.java: Erstelle eine Klasse, die deine funktionale Schnittstelle zur Verarbeitung von Text verwendet. Sie sollte ein Feld besitzen, das einen StringTransformer enthält, sowie einen Konstruktor, um ihn zu initialisieren. Füge eine Methode namens process(String text) ein, die den Transformer auf den angegebenen Text anwendet und das Ergebnis zurückgibt. Dieses Design ermöglicht es dir, über den Konstruktor beliebiges Transformationsverhalten einzuschleusen.
Main.java: Führe alles zusammen, indem du mithilfe von Lambda-Ausdrücken verschiedene Transformationen erstellst. Du erhältst zwei Eingaben: einen Text-String und einen Operationstyp (upper, lower oder reverse).
Erstelle abhängig vom Operationstyp einen TextProcessor mit dem passenden Lambda-Ausdruck:
- upper: wandelt den Text in Großbuchstaben um
- lower: wandelt den Text in Kleinbuchstaben um
- reverse: kehrt den Text um (Tipp: Verwende StringBuilder)
Rufe anschließend process() mit dem Eingabetext auf und gib das Ergebnis in diesem Format aus: Result: [transformed text]

Du erhältst zwei Eingaben: den zu transformierenden Text (String) und den Operationstyp (String).

Beachte, dass dieselbe Klasse TextProcessor abhängig davon, welches Lambda du übergibst, völlig unterschiedliche Operationen ausführen kann: Das ist die Stärke funktionaler Schnittstellen!

Probier es selbst

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: Basierend auf dem Operationstyp erstelle einen TextProcessor mit dem entsprechenden Lambda:
        // - "upper": wandelt Text in Großbuchstaben um
        // - "lower": wandelt Text in Kleinbuchstaben um
        // - "reverse": kehrt den Text um (Hinweis: verwende StringBuilder)
        
        // TODO: Rufe process() mit dem Eingabetext auf und gib das Ergebnis aus
        // Ausgabeformat: "Result: [transformed text]"
    }
}