Java 8 Lambda Expressies beheersen: Gids voor functioneel programmeren

Lambda-expressies zijn in Java 8 geïntroduceerd en worden beschouwd als de grootste feature van Java 8. Lambda-expressies faciliteren functioneel programmeren en vereenvoudigen de ontwikkeling aanzienlijk.

Syntaxis

Een lambda-expressie wordt gekenmerkt door de volgende syntaxis:

parameter -> expression body

Belangrijke kenmerken:

• Optionele type-declaratie – Hoeft niet het type van een parameter te declareren. De compiler deduceert dit uit de waarde.

• Optionele haakjes om parameter – Een enkele parameter hoeft niet tussen haakjes; voor meerdere parameters wel.

• Optionele accolades – Geen accolades nodig als de body uit één statement bestaat.

• Optionele return-sleutelwoord – De compiler retourneert automatisch de waarde als de body een enkele expressie is. Accolades zijn nodig om aan te geven dat er een waarde geretourneerd wordt.

Lambda Expressies Voorbeeld

Maak het volgende Java-programma in, zeg, C:\JAVA.

Java8Tester.java

public class Java8Tester {
    public static void main(String args[]) {
        Java8Tester tester = new Java8Tester();
        // met type declaratie
        MathOperation addition = (int a, int b) -> a + b;
        // zonder type declaratie
        MathOperation subtraction = (a, b) -> a - b;
        // met return statement en accolades
        MathOperation multiplication = (int a, int b) -> { return a * b; };
        // zonder return statement en zonder accolades
        MathOperation division = (int a, int b) -> a / b;

        System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
        System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
        System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
        System.out.println("10 / 5 = " + tester.operate(10, 5, division));

        // zonder haakjes
        GreetingService greetService1 = message -> System.out.println("Hello " + message);
        // met haakjes
        GreetingService greetService2 = (message) -> System.out.println("Hello " + message);
        greetService1.sayMessage("Mahesh");
        greetService2.sayMessage("Suresh");
    }

    interface MathOperation { int operation(int a, int b); }
    interface GreetingService { void sayMessage(String message); }

    private int operate(int a, int b, MathOperation mathOperation) {
        return mathOperation.operation(a, b);
    }
}

Resultaat verifiëren

Compileer met javac:

C:\JAVA> javac Java8Tester.java

Voer uit:

C:\JAVA> java Java8Tester

Uitvoer:

10 + 5 = 15
10 - 5 = 5
10 x 5 = 50
10 / 5 = 2
Hello Mahesh
Hello Suresh

Belangrijke punten:

• Lambda-expressies definiëren inline-implementaties van een functionele interface (interface met één methode). In het voorbeeld definieren we de operation-methode van MathOperation en de sayMessage-methode van GreetingService.
• Lambda-expressies elimineren de noodzaak voor anonieme klassen en geven Java een krachtige functionele programmeermogelijkheid.

Scope

Met lambda-expressies kunt u verwijzen naar elke final variabele of effectively final variabele (waar maar één keer aan toegewezen wordt). De compiler geeft een fout als een variabele een tweede keer een waarde krijgt.

Scope Voorbeeld

public class Java8Tester {
    final static String salutation = "Hello! ";
    public static void main(String args[]) {
        GreetingService greetService1 = message -> System.out.println(salutation + message);
        greetService1.sayMessage("Mahesh");
    }
    interface GreetingService { void sayMessage(String message); }
}

Resultaat verifiëren

Compileer en voer uit; uitvoer: Hello! Mahesh.