Java Academy · Les

Aangepaste functionele interfaces

Een eigen interface definiëren met @FunctionalInterface

Les 4 van 413 stappen

Aangepaste functionele interfaces is een gratis Java Academy-les op CoddyKit. Dit is les 4 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Java Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Java Academy bevat in totaal 4 lessen.

Wat een interface functioneel maakt

Een functionele interface heeft precies één abstracte methode (SAM). Die ene methode is wat een lambda implementeert.

Standaard- en statische methoden tellen niet mee voor de limiet.

interface Greeter {
    String greet(String name);
}

public class Main {
    public static void main(String[] args) {
        Greeter g = name -> "Hello, " + name;
        System.out.println(g.greet("Ada"));
    }
}

De annotatie @FunctionalInterface

@FunctionalInterface vertelt de compiler dat die de regel voor één abstracte methode moet afdwingen. Als je per ongeluk een tweede abstracte methode toevoegt, mislukt de compilatie.

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

public class Main {
    public static void main(String[] args) {
        Calculator add = (a, b) -> a + b;
        System.out.println(add.compute(3, 4));
    }
}

Waarom de annotatie helpt

De annotatie legt de bedoeling vast en beschermt het contract. Zonder de annotatie werkt de interface nog steeds als functionele interface, maar een teamgenoot kan die breken door nog een abstracte methode toe te voegen.

@FunctionalInterface
interface Transformer {
    String apply(String input);
}

public class Main {
    public static void main(String[] args) {
        Transformer reverse = s -> new StringBuilder(s).reverse().toString();
        System.out.println(reverse.apply("abc"));
    }
}

Aangepaste interface met generieke typen

Je interface kan generiek zijn, net als de ingebouwde interfaces.

@FunctionalInterface
interface Converter<S, T> {
    T convert(S source);
}

public class Main {
    public static void main(String[] args) {
        Converter<String, Integer> toInt = Integer::parseInt;
        System.out.println(toInt.convert("123") + 1);
    }
}

Standaardmethoden zijn toegestaan

Een functionele interface mag default-methoden hebben. Ze voegen gedrag toe zonder de regel voor één abstracte methode te breken.

@FunctionalInterface
interface Operation {
    int apply(int x);

    default Operation then(Operation next) {
        return x -> next.apply(this.apply(x));
    }
}

public class Main {
    public static void main(String[] args) {
        Operation inc = x -> x + 1;
        Operation dbl = x -> x * 2;
        System.out.println(inc.then(dbl).apply(5));
    }
}

Ook statische methoden zijn toegestaan

Statische methoden kunnen fungeren als fabrieksmethoden, vergelijkbaar met Function.identity().

@FunctionalInterface
interface Mapper {
    int map(int x);

    static Mapper identity() {
        return x -> x;
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(Mapper.identity().map(99));
    }
}

Gecontroleerde uitzonderingen werpen

Als je abstracte methode een gecontroleerde uitzondering declareert, mag de lambda die werpen. De ingebouwde Function kan dit niet, wat een reden is om zelf een interface te definiëren.

@FunctionalInterface
interface RiskyParser {
    int parse(String s) throws NumberFormatException;
}

public class Main {
    public static void main(String[] args) {
        RiskyParser p = Integer::parseInt;
        System.out.println(p.parse("77"));
    }
}

Aangepaste interfaces aan methoden doorgeven

Je interface wordt een parametertype, waardoor aanroepers gedrag via lambdas kunnen aanleveren.

@FunctionalInterface
interface IntCombiner {
    int combine(int a, int b);
}

public class Main {
    static int reduce(int[] arr, IntCombiner c) {
        int acc = arr[0];
        for (int i = 1; i < arr.length; i++) acc = c.combine(acc, arr[i]);
        return acc;
    }

    public static void main(String[] args) {
        int[] data = {1, 2, 3, 4};
        System.out.println(reduce(data, (a, b) -> a + b));
    }
}

Interface met drie argumenten

De JDK levert alleen interfaces met één en twee argumenten. Voor drie of meer argumenten definieer je je eigen interface.

@FunctionalInterface
interface TriFunction<A, B, C, R> {
    R apply(A a, B b, C c);
}

public class Main {
    public static void main(String[] args) {
        TriFunction<Integer, Integer, Integer, Integer> sum3 = (a, b, c) -> a + b + c;
        System.out.println(sum3.apply(1, 2, 3));
    }
}

Methodeverwijzingen passen bij aangepaste interfaces

Elke methode waarvan de signatuur overeenkomt met de SAM kan als methodeverwijzing worden doorgegeven.

@FunctionalInterface
interface StringTest {
    boolean check(String s);
}

public class Main {
    public static void main(String[] args) {
        StringTest blank = String::isBlank;
        System.out.println(blank.check("   "));
    }
}

Anonieme klasse versus lambda

Een lambda is een beknopte vervanging voor een anonieme klasse die een functionele interface implementeert. Beide leveren hetzelfde gedrag.

@FunctionalInterface
interface Action {
    void run();
}

public class Main {
    public static void main(String[] args) {
        Action old = new Action() {
            public void run() { System.out.println("anonymous"); }
        };
        Action neo = () -> System.out.println("lambda");
        old.run();
        neo.run();
    }
}

Korte controle

Wat garandeert @FunctionalInterface?

Beantwoord dit in de interactieve les

Samenvatting

Je definieerde je eigen functionele interfaces:

Een functionele interface heeft precies één abstracte methode (SAM).
@FunctionalInterface dwingt die regel tijdens het compileren af.
Standaard- en statische methoden, generieke typen en gecontroleerde uitzonderingen zijn allemaal toegestaan.
Aangepaste interfaces vullen gaten die de JDK niet afdekt, zoals functies met drie argumenten of lambdas met gecontroleerde uitzonderingen.

Gratis beginnen

Leer Java met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 104
Lessen: 374

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Aangepaste functionele interfaces” gratis?

Ja — de volledige tekst van “Aangepaste functionele interfaces” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Java Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Java Academy bevat in totaal 4 lessen.

Wat leer ik in “Aangepaste functionele interfaces”?

Een eigen interface definiëren met @FunctionalInterface Je oefent met Java Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Java Academy te beginnen?

Ervaring vooraf is niet nodig. Java Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.

Hoe lang duurt de les “Aangepaste functionele interfaces”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Java Academy?

Ja. Elke les over Java Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Java Academy