0Pricing
Java Academy · Lekcja

Odwołania do metod instancji konkretnego obiektu

Przechwytuj konkretny obiekt i odwołuj się do jednej z jego metod instancji na potrzeby callbacków i listenerów.

Odwołania do metod instancji konkretnego obiektu to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Java Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Java Academy zawiera 4 lekcji w sumie.

Referencja do konkretnej instancji

Referencja do metody instancji na konkretnej instancji przechwytuje określony obiekt i odwołuje się do jednej z jego metod. Składnia: 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

Przechwytywanie instancji własnego obiektu

Można przechwycić dowolny obiekt. Referencja do metody korzysta z instancji istniejącej w chwili jej utworzenia:

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!

Używanie jako Supplier

Bezargumentowa metoda instancji powiązana z konkretnym obiektem pasuje do 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)

Używanie jako Predicate

Metody instancji zwracające wartość logiczną pasują do Predicate, gdy są powiązane z konkretną instancją:

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

Wzorzec listenera i callbacku

Referencje do metod konkretnej instancji świetnie nadają się do listenerów zdarzeń i callbacków — w naturalny sposób przechwytują obiekt obsługujący zdarzenie:

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

Praktyka: Logger powiązany z klasą

Powiąż logger z konkretną instancją loggera, aby używać go jako Consumer:

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

Referencja przechwytuje stan w chwili powiązania

Stan obiektu widoczny za pośrednictwem referencji odzwierciedla jego bieżący stan, a nie migawkę z chwili utworzenia referencji:

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)

Porównanie konkretnej i dowolnej instancji

Dwie różne formy referencji do metod wyglądają podobnie — należy zrozumieć różnicę:

// 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

Przypadek użycia: bezpieczne wątkowo delegowanie metod

Powiąż zsynchronizowaną metodę obiektu usługi z interfejsem funkcyjnym, aby bezpiecznie używać jej asynchronicznie:

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

Gdy przechwycona instancja ma wartość null

Jeśli przechwycony obiekt ma wartość null w chwili tworzenia referencji do metody, NullPointerException zostanie zgłoszony w chwili wywołania, a nie powiązania:

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");
}

Podsumowanie porównania

Porównanie trzech form referencji do metod:

  • ClassName::staticMethod — statyczna, bez odbiorcy
  • instance::instanceMethod — powiązana z konkretnym obiektem
  • ClassName::instanceMethod — odbiorcą jest element strumienia (dowolna instancja)

Szybkie sprawdzenie

Jeśli mamy EventHandler h = new EventHandler(); list.forEach(h::handle); — co jest odbiorcą wywołania handle dla każdego elementu?

Podsumowanie: referencje do metod konkretnej instancji

Najważniejsze informacje:

  • Składnia: instance::methodName — przechwytuje konkretny obiekt
  • Przechwycony obiekt jest odbiorcą każdego wywołania
  • Idealne rozwiązanie dla wywołań zwrotnych, listenerów i wzorców logowania
  • Bieżący stan przechwyconej instancji jest widoczny za pośrednictwem referencji
  • NPE podczas wywołania, jeśli instancja ma wartość null (nie podczas powiązania)

Często zadawane pytania

Czy lekcja „Odwołania do metod instancji konkretnego obiektu” jest bezpłatna?

Tak — pełny tekst „Odwołania do metod instancji konkretnego obiektu” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Java Academy, przejdź na CoddyKit PRO. Kurs Java Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Odwołania do metod instancji konkretnego obiektu”?

Przechwytuj konkretny obiekt i odwołuj się do jednej z jego metod instancji na potrzeby callbacków i listenerów. Ćwiczysz Java Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Java Academy?

Nie wymagamy żadnego doświadczenia. Java Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Odwołania do metod instancji konkretnego obiektu”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Java Academy?

Tak. Każda lekcja Java Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Odwołania do metod statycznych
  2. Odwołania do metod instancji konkretnego obiektu
  3. Odwołania do metod dowolnej instancji
  4. Odwołania do konstruktorów
← Powrót do Java Academy