0Pricing
Java Academy · Lektion

Methodenreferenzen auf einer bestimmten Instanz

Erfassen Sie ein bestimmtes Objekt und referenzieren Sie eine seiner Instanzmethoden für Callbacks und Listener.

Methodenreferenzen auf einer bestimmten Instanz ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 2 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.

Referenz auf eine bestimmte Instanz

Eine Methodenreferenz auf eine Instanz bindet ein bestimmtes Objekt und referenziert eine seiner Methoden. Syntax: instance::methodName.

// System.out is a specific PrintStream instance
List<String> names = List.of("Alice","Bob","Carol");
names.forEach(System.out::println); // System.out is the captured instance

Eine eigene Objektinstanz binden

Jedes Objekt kann gebunden werden. Die Methodenreferenz verwendet die Instanz zum Zeitpunkt ihrer Erstellung:

class Greeter {
    private String prefix;
    Greeter(String prefix) { this.prefix = prefix; }
    String greet(String name) { return prefix + ", " + name + "!"; }
}

Greeter g = new Greeter("Hello");
java.util.function.Function<String, String> greetFn = g::greet;

System.out.println(greetFn.apply("Alice")); // Hello, Alice!
System.out.println(greetFn.apply("Bob"));   // Hello, Bob!

Als Supplier verwenden

Eine parameterlose Instanzmethode, die an ein bestimmtes Objekt gebunden ist, passt zu Supplier<T>:

StringBuilder sb = new StringBuilder("Hello World");
java.util.function.Supplier<String> toString = sb::toString;

System.out.println(toString.get()); // Hello World
sb.append(" !");
System.out.println(toString.get()); // Hello World ! (sb is live)

Als Predicate verwenden

Instanzmethoden mit booleschem Rückgabewert passen zu Predicate, wenn sie an eine bestimmte Instanz gebunden sind:

String prefix = "Java";
java.util.function.Predicate<String> startsWith = prefix::equals;
// Hmm, this checks if prefix.equals(candidate).
// More useful:
Predicate<String> startsWithJ = s -> s.startsWith("J");

// But a specific instance Predicate:
StringBuilder pattern = new StringBuilder("hello");
Predicate<String> equalsHello = ((CharSequence)"hello")::equals;
System.out.println(equalsHello.test("hello")); // true
System.out.println(equalsHello.test("world")); // false

Listener-/Callback-Muster

Methodenreferenzen auf bestimmte Instanzen eignen sich ideal für Event-Listener und Callbacks – sie binden das Handler-Objekt ganz natürlich:

class EventHandler {
    void onEvent(String event) {
        System.out.println("Handling: " + event);
    }
}

EventHandler handler = new EventHandler();
List<String> events = List.of("click","hover","submit");
events.forEach(handler::onEvent); // captures the specific handler instance

Praktisch: Einen Logger an eine Klasse binden

Binden Sie einen Logger an eine bestimmte Logger-Instanz, um ihn als Consumer zu verwenden:

import java.util.logging.*;

Logger log = Logger.getLogger("MyApp");

List<String> messages = List.of("Starting","Processing","Done");
messages.stream()
    .map(String::toUpperCase)
    .forEach(log::info); // log is the specific Logger instance

Referenz erfasst den Zustand zum Bindungszeitpunkt

Der über die Referenz sichtbare Objektzustand entspricht dem aktuellen Zustand des Objekts, nicht einer Momentaufnahme zum Zeitpunkt der Erstellung der Referenz:

List<String> list = new ArrayList<>(List.of("A","B"));
java.util.function.Supplier<Integer> sizeRef = list::size;

System.out.println(sizeRef.get()); // 2
list.add("C");
System.out.println(sizeRef.get()); // 3 (reflects live state)

Spezifische und beliebige Instanz vergleichen

Zwei unterschiedliche Formen von Methodenreferenzen sehen ähnlich aus – verstehen Sie den Unterschied:

// Specific instance: s is captured at binding
String s = "hello";
Predicate<String> p1 = s::equalsIgnoreCase; // String::equalsIgnoreCase bound to 'hello'

// Arbitrary instance: receiver is the stream element
Function<String, String> p2 = String::toUpperCase; // receiver IS the element

Anwendungsfall: Thread-sichere Methodendelegation

Binden Sie eine synchronisierte Methode eines Serviceobjekts als funktionale Schnittstelle für eine sichere asynchrone Verwendung:

class Counter {
    private int count = 0;
    synchronized void increment(String ignored) { count++; }
    int get() { return count; }
}

Counter c = new Counter();
List<String> tasks = List.of("t1","t2","t3");
tasks.forEach(c::increment);
System.out.println(c.get()); // 3

Wenn die erfasste Instanz null ist

Wenn das erfasste Objekt beim Erstellen der Methodenreferenz null ist, wird eine NullPointerException erst zum Zeitpunkt des Aufrufs ausgelöst, nicht zum Bindungszeitpunkt:

StringBuilder sb = null;
// Reference is created without error:
java.util.function.Supplier<String> ref = sb::toString;
try {
    ref.get(); // NPE thrown here
} catch (NullPointerException e) {
    System.out.println("NPE at invocation");
}

Vergleichszusammenfassung

Drei Formen von Methodenreferenzen im Vergleich:

  • ClassName::staticMethod — statisch, ohne Receiver
  • instance::instanceMethod — an ein bestimmtes Objekt gebunden
  • ClassName::instanceMethod — der Receiver ist das Stream-Element (beliebige Instanz)

Kurzer Check

Gegeben sei EventHandler h = new EventHandler(); list.forEach(h::handle); — was ist für jedes Element der Receiver des handle-Aufrufs?

Zusammenfassung: Methodenreferenzen auf eine bestimmte Instanz

Die wichtigsten Punkte:

  • Syntax: instance::methodName — erfasst ein bestimmtes Objekt
  • Das erfasste Objekt ist bei jedem Aufruf der Receiver
  • Ideal für Callbacks, Listener und Logging-Muster
  • Der aktuelle Zustand der erfassten Instanz ist über die Referenz sichtbar
  • NPE beim Aufruf, wenn die Instanz null ist (nicht bei der Bindung)

Häufig gestellte Fragen

Ist die Lektion „Methodenreferenzen auf einer bestimmten Instanz“ kostenlos?

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

Erfassen Sie ein bestimmtes Objekt und referenzieren Sie eine seiner Instanzmethoden für Callbacks und Listener. 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 2 von 4.

Wie lange dauert die Lektion „Methodenreferenzen auf einer bestimmten Instanz“?

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

  1. Statische Methodenreferenzen
  2. Methodenreferenzen auf einer bestimmten Instanz
  3. Methodenreferenzen auf beliebigen Instanzen
  4. Konstruktorreferenzen
← Zurück zu Java Academy