Java Academy · Lektion

Methodenreferenzen auf beliebigen Instanzen

Referenzieren Sie eine Instanzmethode, ohne den Empfänger anzugeben – dies wird häufig bei Stream-Operationen verwendet.

Methodenreferenzen auf beliebigen Instanzen ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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 auf beliebige Instanzen?

Eine Methodenreferenz auf eine beliebige Instanz verwendet ClassName::instanceMethod. Dabei dient das erste Argument der funktionalen Schnittstelle als Receiver — jedes Element wird zu dem Objekt, auf dem die Methode aufgerufen wird.

import java.util.*;
import java.util.stream.*;

List<String> names = List.of("alice","bob","carol");

// String::toUpperCase — receiver is each list element
List<String> upper = names.stream()
    .map(String::toUpperCase)
    .collect(Collectors.toList());
System.out.println(upper); // [ALICE, BOB, CAROL]

So wird der Receiver ermittelt

Bei einer Methodenreferenz auf eine beliebige Instanz Type::method wird der erste Parameter der funktionalen Schnittstelle zu this (dem Receiver):

// String::length matches Function<String, Integer>
// Equivalent to: s -> s.length()
Function<String, Integer> len = String::length;
System.out.println(len.apply("Java")); // 4

// String::isEmpty matches Predicate<String>
// Equivalent to: s -> s.isEmpty()
Predicate<String> isEmpty = String::isEmpty;
System.out.println(isEmpty.test(""));   // true

Intensiv in Stream-Operationen verwendet

Methodenreferenzen auf beliebige Instanzen sind der häufigste Typ in Stream-Pipelines:

List<String> words = List.of("Hello","","World","","Java");

// filter with String::isEmpty
long empty = words.stream().filter(String::isEmpty).count();
System.out.println(empty); // 2

// map with String::toLowerCase
words.stream()
     .filter(s -> !s.isEmpty())
     .map(String::toLowerCase)
     .forEach(System.out::println);

BiFunction-Muster mit Methoden mit zwei Argumenten

Eine Methode mit zwei Argumenten eines Typs passt zu BiFunction<T, U, R>, wobei T der Receiver und U das Argument ist:

import java.util.function.*;

// String::startsWith → BiPredicate<String, String>
// receiver=first arg, argument=second arg
BiPredicate<String, String> starts = String::startsWith;
System.out.println(starts.test("JavaStream", "Java")); // true
System.out.println(starts.test("Python", "Java"));      // false

Comparator mit beliebiger Instanz

String::compareTo passt zu Comparator<String> — die beiden Argumente des Comparators werden zu Receiver und Parameter:

List<String> words = List.of("banana","apple","cherry");

List<String> sorted = words.stream()
    .sorted(String::compareTo)
    .collect(Collectors.toList());
System.out.println(sorted); // [apple, banana, cherry]

Beliebige Instanz einer eigenen Klasse

Funktioniert mit Instanzmethoden beliebiger Klassen, nicht nur mit JDK-Typen:

record Product(String name, double price) {
    boolean isExpensive() { return price > 50; }
    String label() { return name + " ($" + price + ")"; }
}

List<Product> products = List.of(
    new Product("Widget", 9.99),
    new Product("Gadget", 99.99),
    new Product("Donut", 1.50)
);

products.stream()
    .filter(Product::isExpensive)
    .map(Product::label)
    .forEach(System.out::println); // Gadget ($99.99)

Unterschied zur bestimmten Instanz

Der entscheidende Unterschied:

Spezifisch: obj::method — obj ist immer der Receiver
Beliebig: Type::method — jedes Element IST der Receiver

String fixed = "prefix";
// Specific instance: fixed is always the receiver
Predicate<String> startsFixed = fixed::startsWith; // always checks 'prefix'.startsWith(arg)

// Arbitrary instance: each element is the receiver
Predicate<String> isEmpty = String::isEmpty; // each element.isEmpty()

Methodenreferenzen in Collectors

Methodenreferenzen auf beliebige Instanzen lassen sich natürlich mit Collectors kombinieren:

List<String> items = List.of("  hello "," world ","  java  ");
List<String> trimmed = items.stream()
    .map(String::trim)
    .collect(Collectors.toList());
System.out.println(trimmed); // [hello, world, java]

Methodenreferenzen verketten

Methodenreferenzen können mit andThen/compose bei Function verkettet werden:

Function<String, String> pipeline =
    ((Function<String, String>) String::trim)
        .andThen(String::toUpperCase);

System.out.println(pipeline.apply("  hello world  "));
// HELLO WORLD

Fallstrick: Überladene Methoden

Wenn eine Methode überladen ist, muss der Compiler ermitteln, welche Überladung zur funktionalen Schnittstelle passt. Ist die Zuordnung nicht eindeutig, führt das zu einem Kompilierungsfehler — verwenden Sie zur eindeutigen Zuordnung einen Lambda-Ausdruck:

// println is overloaded — which one?
// Consumer<String> c = System.out::println; // OK — infers println(String)
// Consumer<Object> c2 = System.out::println; // OK

// But if ambiguous:
// Function<Object,?> fn = System.out::println; // Error — println doesn't return a value

Leistung

Methodenreferenzen und Lambdas werden in denselben Bytecode kompiliert (über invokedynamic). Es gibt keinen Leistungsunterschied — wählen Sie die Variante, die besser lesbar ist. Die meisten Styleguides bevorzugen Methodenreferenzen, wenn sie die Absicht klar ausdrücken.

Kurzer Check

Was stellt String::toUpperCase bei der Verwendung mit .map() dar?

Zusammenfassung: Methodenreferenzen auf beliebige Instanzen

Die wichtigsten Punkte:

Syntax: ClassName::instanceMethod — jedes Element ist der Receiver
Passt zu funktionalen Schnittstellen, bei denen der Receiver der erste Parameter ist
Am häufigsten in .map(), .filter(), .sorted(), .forEach()
Methoden mit zwei Argumenten → BiFunction/BiPredicate mit dem Element als Receiver
Kein Leistungsunterschied gegenüber einem Lambda — wählen Sie die lesbarere Variante

Häufig gestellte Fragen

Ist die Lektion „Methodenreferenzen auf beliebigen Instanzen“ kostenlos?

Ja — der vollständige Text von „Methodenreferenzen auf beliebigen Instanzen“ 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 „Methodenreferenzen auf beliebigen Instanzen“?

Referenzieren Sie eine Instanzmethode, ohne den Empfänger anzugeben – dies wird häufig bei Stream-Operationen verwendet. 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 3 von 4.

Wie lange dauert die Lektion „Methodenreferenzen auf beliebigen Instanzen“?

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

← Zurück zu Java Academy