0Pricing
Java Academy · Leçon

Références vers des méthodes d’instance précises

Capturez un objet précis et référencez l’une de ses méthodes d’instance pour gérer des rappels et des écouteurs.

Références vers des méthodes d’instance précises est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

Référence vers une instance précise

Une référence vers une méthode d’instance sur une instance précise capture un objet particulier et référence l’une de ses méthodes. Syntaxe : 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

Capturer une instance d’objet personnalisée

N’importe quel objet peut être capturé. La référence de méthode utilise l’instance au moment de sa création :

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!

L’utiliser comme Supplier

Une méthode d’instance sans argument liée à un objet précis correspond à 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)

L’utiliser comme prédicat

Les méthodes d’instance renvoyant une valeur booléenne correspondent à Predicate lorsqu’elles sont liées à une instance précise :

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

Modèle écouteur / rappel

Les références vers des méthodes d’instances précises sont idéales pour les écouteurs d’événements et les rappels : elles capturent naturellement l’objet gestionnaire :

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

Pratique : journaliseur lié à une classe

Liez un journaliseur à une instance précise de journaliseur pour l'utiliser comme consommateur :

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

Une référence capture l'état au moment de l'association

L'état de l'objet visible par l'intermédiaire de la référence reflète l'état actuel de l'objet, et non un instantané pris lors de la création de la référence :

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)

Comparaison entre une instance spécifique et une instance arbitraire

Deux formes distinctes de références de méthode se ressemblent — comprenez la différence :

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

Cas d'utilisation : délégation de méthode sûre pour les threads

Liez une méthode synchronisée d'un objet de service à une interface fonctionnelle pour une utilisation asynchrone sûre :

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

Lorsque l'instance capturée est nulle

Si l'objet capturé est nul lors de la création de la référence de méthode, une NullPointerException est levée au moment de l'appel, et non au moment de l'association :

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

Résumé de la comparaison

Comparaison de trois formes de références de méthode :

  • ClassName::staticMethod — statique, sans récepteur
  • instance::instanceMethod — liée à un objet précis
  • ClassName::instanceMethod — le récepteur est l'élément du flux (instance arbitraire)

Vérification rapide

Étant donné EventHandler h = new EventHandler(); list.forEach(h::handle); — quel est le récepteur de l'appel handle pour chaque élément ?

Récapitulatif : références de méthode sur une instance spécifique

Points essentiels :

  • Syntaxe : instance::methodName — capture un objet précis
  • L'objet capturé est le récepteur de chaque appel
  • Idéale pour les rappels, les écouteurs et les modèles de journalisation
  • L'état actuel de l'instance capturée est visible par l'intermédiaire de la référence
  • NPE lors de l'appel si l'instance est nulle (et non lors de l'association)

Questions Fréquemment Posées

La leçon « Références vers des méthodes d’instance précises » est-elle gratuite ?

Oui — le texte complet de « Références vers des méthodes d’instance précises » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Références vers des méthodes d’instance précises » ?

Capturez un objet précis et référencez l’une de ses méthodes d’instance pour gérer des rappels et des écouteurs. Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Références vers des méthodes d’instance précises » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Références vers des méthodes statiques
  2. Références vers des méthodes d’instance précises
  3. Références vers des méthodes d’instance arbitraires
  4. Références vers des constructeurs
← Retour à Java Academy