Java Academy · Lección

Referencias a métodos de instancia específica

Capture un objeto concreto y haga referencia a uno de sus métodos de instancia para callbacks y listeners.

Referencias a métodos de instancia específica es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.

Referencia a una instancia específica

Una referencia a método de instancia sobre una instancia específica captura un objeto concreto y referencia uno de sus métodos. Sintaxis: 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

Capturar una instancia de un objeto personalizado

Se puede capturar cualquier objeto. La referencia a método utiliza la instancia en el momento de su creación:

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!

Usar como Supplier

Un método de instancia sin argumentos asociado a un objeto específico coincide 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)

Usar como Predicate

Los métodos de instancia que devuelven un valor booleano coinciden con Predicate cuando están asociados a una instancia específica:

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

Patrón de listener / callback

Las referencias a métodos de instancias específicas son ideales para listeners de eventos y callbacks: capturan de forma natural el objeto controlador:

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

Práctica: logger vinculado a una clase

Vincule un logger a una instancia específica de logger para usarlo como 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

La referencia captura el estado en el momento de la vinculación

El estado del objeto visible a través de la referencia refleja el estado actual del objeto, no una instantánea del momento en que se creó la referencia:

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)

Comparación entre una instancia específica y una arbitraria

Dos formas distintas de referencia a métodos tienen un aspecto similar; comprenda la diferencia:

// 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 de uso: delegación de métodos segura para hilos

Vincule un método sincronizado de un objeto de servicio a una interfaz funcional para usarlo de forma asíncrona y segura:

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

Cuando la instancia capturada es null

Si el objeto capturado es null cuando se crea la referencia al método, se produce una NullPointerException en el momento de la invocación, no en el de la vinculación:

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

Resumen de la comparación

Comparación de tres formas de referencias a métodos:

ClassName::staticMethod — estático, sin receptor
instance::instanceMethod — vinculado a un objeto específico
ClassName::instanceMethod — el receptor es el elemento del flujo (instancia arbitraria)

Comprobación rápida

Dado EventHandler h = new EventHandler(); list.forEach(h::handle);, ¿cuál es el receptor de la llamada a handle para cada elemento?

Resumen: referencias a métodos de una instancia específica

Aspectos clave:

Sintaxis: instance::methodName — captura un objeto específico
El objeto capturado es el receptor de cada invocación
Ideal para callbacks, listeners y patrones de logging
El estado actual de la instancia capturada es visible a través de la referencia
NPE en la invocación si la instancia es null, no durante la vinculación

Preguntas frecuentes

¿La lección «Referencias a métodos de instancia específica» es gratis?

Sí — el texto completo de «Referencias a métodos de instancia específica» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Referencias a métodos de instancia específica»?

Capture un objeto concreto y haga referencia a uno de sus métodos de instancia para callbacks y listeners. Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Java Academy?

No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Referencias a métodos de instancia específica»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Java Academy?

Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Referencias a métodos estáticos
Referencias a métodos de instancia específica
Referencias a métodos de instancia arbitraria
Referencias a constructores

← Volver a Java Academy