Java Academy · Lezione

Riferimenti a metodi di istanza su un'istanza specifica

Catturi un oggetto specifico e ne utilizzi un metodo di istanza come riferimento per callback e listener.

Riferimenti a metodi di istanza su un'istanza specifica è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Riferimento a un'istanza specifica

Un riferimento a un metodo di istanza su un'istanza specifica cattura un oggetto preciso e fa riferimento a uno dei suoi metodi. Sintassi: 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

Cattura di un'istanza di un oggetto personalizzato

È possibile catturare qualsiasi oggetto. Il riferimento al metodo utilizza l'istanza al momento della creazione:

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!

Utilizzo come Supplier

Un metodo di istanza senza argomenti associato a un oggetto specifico è compatibile con 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)

Utilizzo come Predicate

I metodi di istanza che restituiscono un valore booleano sono compatibili con Predicate quando sono associati a un'istanza specifica:

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

Pattern listener / callback

I riferimenti a metodi su istanze specifiche sono ideali per i listener di eventi e i callback: catturano naturalmente l'oggetto gestore:

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

Pratica: logger associato a una classe

Associ un logger a una specifica istanza di logger per utilizzarlo come 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

Il riferimento acquisisce lo stato al momento dell'associazione

Lo stato dell'oggetto visibile attraverso il riferimento riflette lo stato attuale dell'oggetto, non uno snapshot del momento in cui il riferimento è stato creato:

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)

Confronto tra istanza specifica e istanza arbitraria

Due forme distinte di riferimento a un metodo hanno un aspetto simile: è importante comprenderne la differenza:

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

Caso d'uso: delega di metodi thread-safe

Associ un metodo sincronizzato di un oggetto servizio a un'interfaccia funzionale per utilizzarlo in modo sicuro in operazioni asincrone:

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

Quando l'istanza acquisita è null

Se l'oggetto acquisito è null quando viene creato il riferimento al metodo, viene generata una NullPointerException al momento dell'invocazione, non al momento dell'associazione:

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

Riepilogo del confronto

Confronto tra tre forme di riferimento a un metodo:

ClassName::staticMethod — statico, senza ricevitore
instance::instanceMethod — associato a un oggetto specifico
ClassName::instanceMethod — il ricevitore è l'elemento dello stream (istanza arbitraria)

Verifica rapida

Dato EventHandler h = new EventHandler(); list.forEach(h::handle);, qual è il ricevitore della chiamata a handle per ogni elemento?

Riepilogo: riferimenti a metodi di un'istanza specifica

Punti chiave:

Sintassi: instance::methodName — acquisisce un oggetto specifico
L'oggetto acquisito è il ricevitore di ogni invocazione
Ideale per callback, listener e pattern di logging
Lo stato attuale dell'istanza acquisita è visibile attraverso il riferimento
NPE al momento dell'invocazione se l'istanza è null, non al momento dell'associazione

Domande Frequenti

La lezione «Riferimenti a metodi di istanza su un'istanza specifica» è gratuita?

Sì — il testo completo di «Riferimenti a metodi di istanza su un'istanza specifica» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «Riferimenti a metodi di istanza su un'istanza specifica»?

Catturi un oggetto specifico e ne utilizzi un metodo di istanza come riferimento per callback e listener. Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Riferimenti a metodi di istanza su un'istanza specifica»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Riferimenti a metodi statici
Riferimenti a metodi di istanza su un'istanza specifica
Riferimenti a metodi di istanza arbitraria
Riferimenti a costruttori

← Torna a Java Academy