0Pricing
Java Academy · Aula

Referências a Métodos de Instância Específica

Capture um objeto específico e referencie um de seus métodos de instância para retornos de chamada e listeners.

Referências a Métodos de Instância Específica é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

Referência a uma instância específica

Uma referência a método de instância em uma instância específica captura um objeto específico e referencia um de seus métodos. Sintaxe: 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

Capturando uma instância de objeto personalizado

Qualquer objeto pode ser capturado. A referência ao método utiliza a instância no momento de sua criação:

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!

Usando como Supplier

Um método de instância sem argumentos, associado a um objeto específico, corresponde a 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)

Usando como predicado

Métodos de instância que retornam um valor booleano correspondem a Predicate quando associados a uma instância 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

Padrão de ouvinte / função de retorno

Referências a métodos de uma instância específica são ideais para ouvintes de eventos e funções de retorno — elas capturam naturalmente o objeto manipulador:

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ática: Registrador Vinculado a uma Classe

Vincule um registrador a uma instância específica para usá-lo como um consumidor:

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

A Referência Captura o Estado no Momento da Vinculação

O estado do objeto visível por meio da referência reflete o estado atual do objeto, não uma cópia do momento em que a referência foi criada:

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)

Comparando Instâncias Específicas e Arbitrárias

Duas formas distintas de referência de método parecem semelhantes — compreenda a diferença:

// 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: Delegação de Método Segura para Execução Concorrente

Vincule um método sincronizado em um objeto de serviço a uma interface funcional para uso assíncrono seguro:

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 a Instância Capturada é Nula

Se o objeto capturado for nulo quando a referência de método for criada, uma NullPointerException será lançada no momento da invocação, não no momento da vinculação:

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

Resumo da Comparação

Três formas de referência de método comparadas:

  • ClassName::staticMethod — estática, sem receptor
  • instância::instanceMethod — vinculada a um objeto específico
  • ClassName::instanceMethod — o receptor é o elemento do fluxo (instância arbitrária)

Verificação Rápida

Dado EventHandler h = new EventHandler(); list.forEach(h::handle); — qual é o receptor da chamada handle para cada elemento?

Recapitulação: Referências de Método de Instância Específica

Principais conclusões:

  • Sintaxe: instância::methodName — captura um objeto específico
  • O objeto capturado é o receptor de todas as invocações
  • Ideal para retornos de chamada, ouvintes e padrões de registro em log
  • O estado atual da instância capturada fica visível por meio da referência
  • NPE na invocação se a instância for nula, não na vinculação

Perguntas Frequentes

A aula “Referências a Métodos de Instância Específica” é grátis?

Sim — o texto completo de “Referências a Métodos de Instância Específica” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Referências a Métodos de Instância Específica”?

Capture um objeto específico e referencie um de seus métodos de instância para retornos de chamada e listeners. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Referências a Métodos de Instância Específica”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Referências a Métodos Estáticos
  2. Referências a Métodos de Instância Específica
  3. Referências a Métodos de Instância Arbitrária
  4. Referências a Construtores
← Voltar para Java Academy