Benutzerdefinierte funktionale Interfaces
Mit @FunctionalInterface eigene definieren
Benutzerdefinierte funktionale Interfaces ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.
Was ein Interface funktional macht
Ein funktionales Interface verfügt über genau eine abstrakte Methode (SAM). Diese einzelne Methode wird von einem Lambda-Ausdruck implementiert.
- Default- und statische Methoden werden nicht auf das Limit angerechnet.
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"));
}
}Die Annotation @FunctionalInterface
@FunctionalInterface weist den Compiler an, die Regel für genau eine abstrakte Methode durchzusetzen. Wenn Sie versehentlich eine zweite abstrakte Methode hinzufügen, schlägt die Kompilierung fehl.
@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));
}
}Warum die Annotation hilfreich ist
Die Annotation dokumentiert die Absicht und schützt den Vertrag. Ohne sie funktioniert das Interface weiterhin als funktionales Interface, aber ein Teammitglied könnte es durch das Hinzufügen einer weiteren abstrakten Methode unbrauchbar machen.
@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"));
}
}Benutzerdefiniertes Interface mit Generics
Ihr Interface kann generisch sein, genau wie die integrierten 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);
}
}Default-Methoden sind erlaubt
Ein funktionales Interface darf default-Methoden enthalten. Sie fügen Verhalten hinzu, ohne die Regel für genau eine abstrakte Methode zu verletzen.
@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));
}
}Statische Methoden sind ebenfalls erlaubt
Statische Methoden können als Factory-Methoden dienen, ähnlich wie 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));
}
}Geprüfte Ausnahmen auslösen
Wenn Ihre abstrakte Methode eine geprüfte Ausnahme deklariert, darf die Lambda diese auslösen. Das integrierte Function kann dies nicht, was ein Grund dafür ist, ein eigenes Interface zu definieren.
@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"));
}
}Benutzerdefinierte Interfaces an Methoden übergeben
Ihr Interface wird zu einem Parametertyp, sodass Aufrufer Verhalten über Lambdas bereitstellen können.
@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 für drei Argumente
Das JDK liefert nur Interfaces für ein oder zwei Argumente aus. Für drei oder mehr Argumente definieren Sie ein eigenes 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));
}
}Methodenreferenzen passen zu benutzerdefinierten Interfaces
Jede Methode, deren Signatur mit der SAM übereinstimmt, kann als Methodenreferenz übergeben werden.
@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(" "));
}
}Anonyme Klasse vs. Lambda
Ein Lambda-Ausdruck ist eine kompakte Alternative zu einer anonymen Klasse, die ein funktionales Interface implementiert. Beide erzeugen dasselbe Verhalten.
@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();
}
}Schnelltest
Was garantiert @FunctionalInterface?
Zusammenfassung
Sie haben eigene funktionale Interfaces definiert:
- Ein funktionales Interface verfügt über genau eine abstrakte Methode (SAM).
@FunctionalInterfacesetzt diese Regel zur Compile-Zeit durch.- Default- und statische Methoden, Generics sowie geprüfte Ausnahmen sind alle erlaubt.
- Benutzerdefinierte Interfaces schließen Lücken, die das JDK nicht abdeckt, etwa Funktionen mit drei Argumenten oder Lambdas mit geprüften Ausnahmen.
Häufig gestellte Fragen
Ist die Lektion „Benutzerdefinierte funktionale Interfaces“ kostenlos?
Ja — der vollständige Text von „Benutzerdefinierte funktionale Interfaces“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Benutzerdefinierte funktionale Interfaces“?
Mit @FunctionalInterface eigene definieren Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Java Academy zu starten?
Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.
Wie lange dauert die Lektion „Benutzerdefinierte funktionale Interfaces“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?
Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Function und BiFunction
- Supplier und Consumer
- Predicate und Komposition
- Benutzerdefinierte funktionale Interfaces