Antwoord.

Functioneel programmeren in Java heeft zich ontwikkeld met de opkomst van lambda-expressies en functionele interfaces (sinds Java 8).

Geschiedenis van de kwestie

Voor de komst van Java 8 waren alle interfaces slechts een set abstracte methoden, en was de paradigma gericht op OOP. Met de introductie van functionele interfaces en lambda-expressies kwam de mogelijkheid om kortere code te schrijven en de principes van FP te volgen, wat de leesbaarheid en expressiviteit van de code verhoogde.

Probleem

Code gerelateerd aan event processing, collecties of asynchrone logica werd overbodig: het was nodig om aparte klassen of anonieme innerlijke klassen te maken. Dit bemoeilijkte het onderhoud en de schaling van de code.

Oplossing

Een functionele interface is een interface met precies één abstracte methode. Het kan worden gebruikt als de doeltoepassing voor een lambda-expressie. Er zijn standaard functionele interfaces in de bibliotheek verschenen, zoals Function<T, R>, Predicate<T>, Supplier<T>, Consumer<T>, evenals de mogelijkheid om eigen interfaces te creëren.

Voorbeeldcode:

import java.util.function.Function;

public class FunctionalExample {
    public static void main(String[] args) {
        // Standaard functionele interface Function
        Function<String, Integer> stringLength = s -> s.length();
        System.out.println(stringLength.apply("Java")); // Geeft 4 weer
    }
}

Belangrijke kenmerken:

Stellen het gebruik van beknopte lambda-expressies mogelijk.
Verbeteren aanzienlijk de leesbaarheid, vooral bij streamoperaties.
Voorkomen boilerplate-code, maken het verwerken van events, filteren en verwerken van collecties elegant.

Vragen met een valstrik.

Kan een functionele interface met meerdere abstracte methoden worden gedeclareerd, als de andere methoden een standaardimplementatie of statisch zijn?

Nee, een functionele interface kan alleen één abstracte methode bevatten. Een default-methode (default) of statische methode is toegestaan.

Kan een functionele interface worden geërfd van een andere interface met meerdere abstracte methoden?

Nee, als de uiteindelijke interface meer dan één abstracte methode heeft, is deze geen functionele interface meer en kan deze niet worden gebruikt voor de substitutie van een lambda-expressie.

Wat is het verschil tussen een functionele interface in Java en SAM-interfaces in andere talen, zoals C#?

In Java is er geen direct sleutelwoord voor het declareren van SAM-interfaces totdat de annotatie @FunctionalInterface verscheen. In tegenstelling tot C#, waar delegate de handtekening duidelijk definieert, is in Java slechts één abstracte methode en een optionele annotatie voor de compiler voldoende.

Typische fouten en anti-patronen

Vergeten van de annotatie @FunctionalInterface — de compiler geeft niet onmiddellijk een foutmelding als de interface geen functionele interface meer is.
Onbewust toevoegen van een abstracte methode in de interface, wat de functionaliteit ervan verstoort.
Gebruik van lambdas daar waar het gedrag geen uitdrukking van logica is, maar entiteiten beschrijft (verlies van leesbaarheid).

Voorbeeld uit het leven

Negatieve case

In een groot project besloten ze om lambda's overal te gebruiken, ook daar waar entiteiten gegevens vertegenwoordigden die niet rechtstreeks met de bedrijfslogica waren verbonden. Als gevolg was het moeilijk om de complexe logica te volgen, aangezien lambda's de bedoelingen van de code verdoezelden, wat de debugging bemoeilijkte.

Voordelen:

Beknopte code.
Minder boilerplate.

Nadelen:

Verlies van leesbaarheid.
Fouten bij het modificeren van interfaces.

Positieve case

In een ander project werd zorgvuldig geanalyseerd welke interfaces geschikt waren voor FP. Ze gebruikten Predicate, Function en hun eigen interfaces voor het verwerken van collecties en events. Voor entiteiten en dataverwerking werd FP niet toegepast.