Java 8 Lambda Expressions meistern: Funktionale Programmierung leicht gemacht

Was sind Lambda Expressions?

Lambda Expressions (JSR 335) ermöglichen funktionale Programmierung in Java: Verhalten als Daten weiterreichen, ohne anonyme Klassen-Boilerplate. Ein Lambda implementiert ein Functional Interface (Interface mit genau einer abstrakten Methode).

Syntax

(parameter) -> ausdruck
(parameter) -> { anweisungen; return wert; }

Vereinfachungen

• Typinferenz: Parametertypen weglassen: (a, b) -> a + b.
• Ein Parameter, keine Klammern: s -> s.length().
• Ein Ausdruck, keine Klammern/return: () -> 42, x -> x * 2.
• Block mit return: (int a, int b) -> { return a + b; }.

Beispiel: Rechenoperationen & Grüße

public class LambdaDemo {
    public static void main(String[] args) {
        LambdaDemo demo = new LambdaDemo();

        // Functional Interfaces
        MathOp add = (int a, int b) -> a + b;
        MathOp sub = (a, b) -> a - b;               // Typinferenz
        MathOp mul = (int a, int b) -> { return a * b; }; // Block + return
        MathOp div = (int a, int b) -> a / b;

        System.out.println("10 + 5 = " + demo.operate(10, 5, add));
        System.out.println("10 - 5 = " + demo.operate(10, 5, sub));
        System.out.println("10 * 5 = " + demo.operate(10, 5, mul));
        System.out.println("10 / 5 = " + demo.operate(10, 5, div));

        // Ohne Parameter-Typ, ohne Klammern
        Greeting g1 = msg -> System.out.println("Hallo " + msg);
        // Mit Klammern
        Greeting g2 = (msg) -> System.out.println("Hallo " + msg);

        g1.say("Anna");
        g2.say("Bernd");
    }

    interface MathOp { int op(int a, int b); }
    interface Greeting { void say(String msg); }

    private int operate(int a, int b, MathOp op) { return op.op(a, b); }
}

Ausgabe:

10 + 5 = 15
10 - 5 = 5
10 * 5 = 50
10 / 5 = 2
Hallo Anna
Hallo Bernd

Wichtige Punkte

• Lambdas implementieren Functional Interfaces (SAM – Single Abstract Method).
• Ersetzen anonyme Klassen: new Runnable() { public void run() {...} } → () -> {...}.
• Kein eigener Scope: Lambdas teilen den Scope der umgebenden Methode (kein this-Schatten).
• Variablen-Capture: Nur final oder effektiv final (einmal zugewiesene) lokale Variablen nutzbar.

Scope-Beispiel

public class ScopeDemo {
    final static String GRUSS = "Hallo ";

    public static void main(String[] args) {
        Greeting g = name -> System.out.println(GRUSS + name); // Static final OK
        g.say("Welt");
    }
    interface Greeting { void say(String name); }
}

Häufige Functional Interfaces (java.util.function)

Fazit

Lambdas sind der Türöffner für funktionale Programmierung in Java. Sie machen Code kürzer, lesbarer und ermöglichen die mächtige Stream-API. Verstehen Sie Functional Interfaces, um Lambdas effektiv einzusetzen.