Statische Methodenreferenzen
Ersetzen Sie Lambdas, die statische Methoden aufrufen, durch Referenzen im Format ClassName::methodName.
Statische Methodenreferenzen ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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 sind Methodenreferenzen?
Eine Methodenreferenz ist eine Kurzform für einen Lambda-Ausdruck, der an eine vorhandene Methode delegiert. Wenn ein Lambda-Ausdruck lediglich eine einzelne Methode aufrufen würde, ist eine Methodenreferenz übersichtlicher und besser lesbar.
import java.util.*;
import java.util.stream.*;
List<String> names = List.of("Alice", "Bob", "Carol");
// Lambda:
names.forEach(s -> System.out.println(s));
// Equivalent method reference:
names.forEach(System.out::println);Syntax einer statischen Methodenreferenz
Eine statische Methodenreferenz hat die Form ClassName::staticMethodName. Sie kann überall dort verwendet werden, wo eine funktionale Schnittstelle eine Methode mit derselben Signatur erwartet.
import java.util.stream.*;
// Integer.parseInt(String) matches Function<String, Integer>
List<String> strs = List.of("1","2","3","4","5");
List<Integer> nums = strs.stream()
.map(Integer::parseInt) // replaces s -> Integer.parseInt(s)
.collect(Collectors.toList());
System.out.println(nums); // [1, 2, 3, 4, 5]Math.abs als Methodenreferenz
Statische Methoden aus Hilfsklassen wie Math können direkt referenziert werden:
import java.util.*;
import java.util.stream.*;
List<Integer> values = List.of(-3, 5, -1, 8, -4);
List<Integer> abs = values.stream()
.map(Math::abs) // replaces v -> Math.abs(v)
.collect(Collectors.toList());
System.out.println(abs); // [3, 5, 1, 8, 4]Statische Methodenreferenz mit Predicate
Statische Methoden mit einem passenden booleschen Rückgabewert können als Predicate verwendet werden:
import java.util.stream.*;
// String.isEmpty() is an instance method, but we can use a static helper
// Objects.isNull matches Predicate<Object>
List<String> mixed = Arrays.asList("hello", null, "world", null);
long nullCount = mixed.stream()
.filter(Objects::isNull)
.count();
System.out.println(nullCount); // 2
long nonNull = mixed.stream()
.filter(Objects::nonNull)
.count();
System.out.println(nonNull); // 2Statische Comparator-Referenz
Statische Methoden, die zu Comparator passen, können ebenfalls referenziert werden:
import java.util.*;
import java.util.stream.*;
List<String> words = List.of("banana", "apple", "cherry");
// String.CASE_INSENSITIVE_ORDER is a Comparator
List<String> sorted = words.stream()
.sorted(String::compareToIgnoreCase)
.collect(Collectors.toList());
System.out.println(sorted); // [apple, banana, cherry]Eigene statische Hilfsmethode
Definieren Sie eine statische Hilfsmethode und referenzieren Sie sie direkt:
class Validator {
static boolean isPositive(int n) { return n > 0; }
static String toLabel(int n) { return n > 0 ? "POS" : "NEG"; }
}
List<Integer> nums = List.of(-2, 3, -1, 5, 0);
List<Integer> positive = nums.stream()
.filter(Validator::isPositive)
.collect(Collectors.toList());
System.out.println(positive); // [3, 5]
List<String> labels = nums.stream()
.map(Validator::toLabel)
.collect(Collectors.toList());BiFunction mit statischer Methode
Statische Methoden mit zwei Parametern können zu BiFunction<T,U,R> passen:
import java.util.function.*;
// Math.max(int,int) → BiFunction... but needs IntBinaryOperator
java.util.function.IntBinaryOperator maxOp = Math::max;
System.out.println(maxOp.applyAsInt(7, 3)); // 7
// String.format as BiFunction? Only works if signature matches:
// Integer.sum(int,int) → IntBinaryOperator
java.util.function.IntBinaryOperator sum = Integer::sum;
System.out.println(sum.applyAsInt(10, 20)); // 30Sortieren mit Comparator.comparing + statischer Referenz
Kombinieren Sie Comparator.comparing mit Methodenreferenzen für eine übersichtliche Sortierung:
record Person(String name, int age) {}
List<Person> people = List.of(
new Person("Charlie",30), new Person("Alice",25), new Person("Bob",35)
);
people.stream()
.sorted(Comparator.comparing(Person::name))
.forEach(p -> System.out.println(p.name()));
// Alice, Bob, CharlieWann statische Methodenreferenzen verwendet werden
Verwenden Sie statische Methodenreferenzen, wenn:
- der Lambda-Ausdruck aus einem einzigen Aufruf einer statischen Methode besteht
- keine Umwandlung der Argumente erforderlich ist
- die Methodensignatur zur funktionalen Schnittstelle passt
Wenn Sie Argumente umwandeln oder zusätzliche Logik hinzufügen müssen, verwenden Sie weiterhin einen Lambda-Ausdruck.
Vergleich der Lesbarkeit
Direkter Vergleich der Schreibweisen von Lambda-Ausdruck und Methodenreferenz:
// Lambda style
Stream.of("1","2","3").map(s -> Integer.parseInt(s));
Stream.of(1,-2,3).filter(n -> n > 0);
Stream.of(-5,2,-1).map(n -> Math.abs(n));
// Method reference style
Stream.of("1","2","3").map(Integer::parseInt);
Stream.of(1,-2,3).filter(Validator::isPositive);
Stream.of(-5,2,-1).map(Math::abs);Häufiger Fehler: Falsche Signatur
Eine Methodenreferenz funktioniert nur, wenn ihre Signatur exakt zur abstrakten Methode der funktionalen Schnittstelle passt. Wenn sich die Typen oder die Anzahl der Argumente unterscheiden, verwenden Sie stattdessen einen Lambda-Ausdruck als Wrapper.
// Math.pow(double, double) needs two args — can't use as Function<Double, Double>
// This won't compile:
// Function<Double, Double> square = Math::pow; // ERROR
// Fix with lambda:
Function<Double, Double> square = n -> Math.pow(n, 2);
System.out.println(square.apply(5.0)); // 25.0Kurze Überprüfung
Welche der folgenden Methodenreferenzen ist gültig und kann als Predicate<Object> verwendet werden?
Rückblick: Statische Methodenreferenzen
Die wichtigsten Punkte:
- Syntax: ClassName::staticMethodName
- Ersetzt Lambda-Ausdrücke, die an eine einzelne statische Methode delegieren
- Die Methodensignatur muss zur abstrakten Methode der funktionalen Schnittstelle passen
- Funktioniert mit Predicate, Function, Consumer, Comparator usw.
- Verwenden Sie Lambda-Ausdrücke, wenn eine Argumentumwandlung oder zusätzliche Logik erforderlich ist
Häufig gestellte Fragen
Ist die Lektion „Statische Methodenreferenzen“ kostenlos?
Ja — der vollständige Text von „Statische Methodenreferenzen“ 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 „Statische Methodenreferenzen“?
Ersetzen Sie Lambdas, die statische Methoden aufrufen, durch Referenzen im Format ClassName::methodName. 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 1 von 4.
Wie lange dauert die Lektion „Statische Methodenreferenzen“?
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
- Statische Methodenreferenzen
- Methodenreferenzen auf einer bestimmten Instanz
- Methodenreferenzen auf beliebigen Instanzen
- Konstruktorreferenzen