Java Academy · Les

Verwijzingen naar instantiemethoden zonder specifieke instantie

Verwijs naar een instantiemethode zonder de ontvanger op te geven — veelgebruikt bij Stream-bewerkingen.

Les 3 van 413 stappen

Verwijzingen naar instantiemethoden zonder specifieke instantie is een gratis Java Academy-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Java Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Java Academy bevat in totaal 4 lessen.

Wat zijn verwijzingen naar willekeurige instanties?

Een methodereferentie naar een willekeurige instantie gebruikt ClassName::instanceMethod. Hierbij fungeert het eerste argument van de functionele interface als ontvanger — elk element wordt het object waarop de methode wordt aangeroepen.

import java.util.*;
import java.util.stream.*;

List<String> names = List.of("alice","bob","carol");

// String::toUpperCase — receiver is each list element
List<String> upper = names.stream()
    .map(String::toUpperCase)
    .collect(Collectors.toList());
System.out.println(upper); // [ALICE, BOB, CAROL]

Hoe de ontvanger wordt bepaald

Bij een verwijzing naar een willekeurige instantie Type::method wordt de eerste parameter van de functionele interface this (de ontvanger):

// String::length matches Function<String, Integer>
// Equivalent to: s -> s.length()
Function<String, Integer> len = String::length;
System.out.println(len.apply("Java")); // 4

// String::isEmpty matches Predicate<String>
// Equivalent to: s -> s.isEmpty()
Predicate<String> isEmpty = String::isEmpty;
System.out.println(isEmpty.test(""));   // true

Veel gebruikt bij streambewerkingen

Verwijzingen naar willekeurige instanties zijn het meest voorkomende type in streampijplijnen:

List<String> words = List.of("Hello","","World","","Java");

// filter with String::isEmpty
long empty = words.stream().filter(String::isEmpty).count();
System.out.println(empty); // 2

// map with String::toLowerCase
words.stream()
     .filter(s -> !s.isEmpty())
     .map(String::toLowerCase)
     .forEach(System.out::println);

BiFunction-stijl met methoden met twee argumenten

Een methode met twee argumenten op een type past bij BiFunction<T, U, R>, waarbij T de ontvanger is en U het argument:

import java.util.function.*;

// String::startsWith → BiPredicate<String, String>
// receiver=first arg, argument=second arg
BiPredicate<String, String> starts = String::startsWith;
System.out.println(starts.test("JavaStream", "Java")); // true
System.out.println(starts.test("Python", "Java"));      // false

Comparator met willekeurige instantie

String::compareTo past bij Comparator<String> — de twee argumenten van de comparator worden de ontvanger en de parameter:

List<String> words = List.of("banana","apple","cherry");

List<String> sorted = words.stream()
    .sorted(String::compareTo)
    .collect(Collectors.toList());
System.out.println(sorted); // [apple, banana, cherry]

Willekeurige instantie bij een aangepaste klasse

Dit werkt met instantiemethoden van elke klasse, niet alleen met JDK-typen:

record Product(String name, double price) {
    boolean isExpensive() { return price > 50; }
    String label() { return name + " ($" + price + ")"; }
}

List<Product> products = List.of(
    new Product("Widget", 9.99),
    new Product("Gadget", 99.99),
    new Product("Donut", 1.50)
);

products.stream()
    .filter(Product::isExpensive)
    .map(Product::label)
    .forEach(System.out::println); // Gadget ($99.99)

Verschil met een specifieke instantie

Het belangrijkste verschil:

Specifiek: obj::method — obj is altijd de ontvanger
Willekeurig: Type::method — elk element IS de ontvanger

String fixed = "prefix";
// Specific instance: fixed is always the receiver
Predicate<String> startsFixed = fixed::startsWith; // always checks 'prefix'.startsWith(arg)

// Arbitrary instance: each element is the receiver
Predicate<String> isEmpty = String::isEmpty; // each element.isEmpty()

Methodereferenties in verzamelaars

Verwijzingen naar willekeurige instanties combineren natuurlijk met verzamelaars:

List<String> items = List.of("  hello "," world ","  java  ");
List<String> trimmed = items.stream()
    .map(String::trim)
    .collect(Collectors.toList());
System.out.println(trimmed); // [hello, world, java]

Methodereferenties koppelen

Methodereferenties kunnen met andThen/compose op Function worden gekoppeld:

Function<String, String> pipeline =
    ((Function<String, String>) String::trim)
        .andThen(String::toUpperCase);

System.out.println(pipeline.apply("  hello world  "));
// HELLO WORLD

Valkuil: overladen methoden

Wanneer een methode overladen is, moet de compiler afleiden welke overbelasting bij de functionele interface past. Bij onduidelijkheid ontstaat er een compilatiefout — gebruik een lambda om het onderscheid expliciet te maken:

// println is overloaded — which one?
// Consumer<String> c = System.out::println; // OK — infers println(String)
// Consumer<Object> c2 = System.out::println; // OK

// But if ambiguous:
// Function<Object,?> fn = System.out::println; // Error — println doesn't return a value

Prestaties

Methodereferenties en lambda's worden naar dezelfde bytecode gecompileerd (via invokedynamic). Er is geen verschil in prestaties — kies wat het duidelijkst leesbaar is. De meeste stijlgidsen geven de voorkeur aan methodereferenties wanneer die de bedoeling helder uitdrukken.

Korte controle

Wat stelt String::toUpperCase voor wanneer je dit met .map() gebruikt?

Beantwoord dit in de interactieve les

Samenvatting: methodereferenties naar willekeurige instanties

Belangrijkste punten:

Syntax: ClassName::instanceMethod — elk element is de ontvanger
Past bij functionele interfaces waarbij de ontvanger de eerste parameter is
Het meest gebruikelijk in .map(), .filter(), .sorted() en .forEach()
Methoden met twee argumenten → BiFunction/BiPredicate met het element als ontvanger
Geen prestatieverschil met een lambda — kies op basis van leesbaarheid

Gratis beginnen

Leer Java met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 104
Lessen: 374

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Verwijzingen naar instantiemethoden zonder specifieke instantie” gratis?

Ja — de volledige tekst van “Verwijzingen naar instantiemethoden zonder specifieke instantie” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Java Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Java Academy bevat in totaal 4 lessen.

Wat leer ik in “Verwijzingen naar instantiemethoden zonder specifieke instantie”?

Verwijs naar een instantiemethode zonder de ontvanger op te geven — veelgebruikt bij Stream-bewerkingen. Je oefent met Java Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Java Academy te beginnen?

Ervaring vooraf is niet nodig. Java Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “Verwijzingen naar instantiemethoden zonder specifieke instantie”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Java Academy?

Ja. Elke les over Java Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

Verwijzingen naar statische methoden
Verwijzingen naar instantiemethoden van een specifieke instantie
Verwijzingen naar instantiemethoden zonder specifieke instantie
Verwijzingen naar constructors

← Terug naar Java Academy