Java Academy · Lektion

Referencer til instansmetoder uden bestemt instans

Referér til en instansmetode uden at angive modtageren – det bruges ofte sammen med Stream-operationer.

Lektion 3 af 413 trin

Referencer til instansmetoder uden bestemt instans er en gratis Java Academy-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Java Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Java Academy-kurset indeholder 4 lektioner i alt.

Hvad er referencer til vilkårlige instanser?

En metodereference til en vilkårlig instans bruger ClassName::instanceMethod. Her fungerer den funktionelle grænseflades første argument som modtager — hvert element bliver det objekt, som metoden kaldes på.

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]

Sådan bestemmes modtageren

For en reference til en vilkårlig instans, Type::method, bliver den funktionelle grænseflades første parameter til this (modtageren):

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

Bruges meget i strømbehandlingskæder

Referencer til vilkårlige instanser er den mest almindelige type i strømbehandlingskæder:

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-stil med metoder med to argumenter

En metode med to argumenter på en type passer til BiFunction<T, U, R>, hvor T er modtageren, og U er argumentet:

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 med vilkårlig instans

String::compareTo passer til Comparator<String> — comparatorens to argumenter bliver til henholdsvis modtager og 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]

Vilkårlig instans i en brugerdefineret klasse

Det fungerer med instansmetoder i enhver klasse, ikke kun JDK-typer:

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)

Forskellen fra en specifik instans

Den afgørende forskel:

Specifik: obj::method — obj er altid modtageren
Vilkårlig: Type::method — hvert element ER modtageren

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()

Metodereferencer i samlere

Referencer til vilkårlige instanser kombineres naturligt med samlere:

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]

Kædning af metodereferencer

Metodereferencer kan kædes med andThen/compose på Function:

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

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

Faldgrube: Overbelastede metoder

Når en metode er overbelastet, skal compileren udlede, hvilken overbelastning der passer til den funktionelle grænseflade. Hvis valget ikke er entydigt, er det en kompileringsfejl — brug en lambda til at gøre valget entydigt:

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

Ydeevne

Metodereferencer og lambdaer kompileres til den samme bytekode (via invokedynamic). Der er ingen forskel i ydeevnen — vælg den form, der er mest læselig. De fleste stilvejledninger foretrækker metodereferencer, når de tydeligt udtrykker hensigten.

Hurtig kontrol

Hvad repræsenterer String::toUpperCase, når det bruges sammen med .map()?

Besvar den i den interaktive lektion

Opsummering: Metodereferencer til vilkårlige instanser

Vigtige pointer:

Syntaks: ClassName::instanceMethod — hvert element er modtageren
Passer til funktionelle grænseflader, hvor modtageren er den første parameter
Ses oftest i .map(), .filter(), .sorted() og .forEach()
Metoder med to argumenter → BiFunction/BiPredicate med elementet som modtager
Ingen forskel i ydeevnen sammenlignet med en lambda — vælg ud fra læselighed

Gratis at komme i gang

Lær Java med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 104
Lektioner: 374

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Referencer til instansmetoder uden bestemt instans” gratis?

Ja — hele teksten til “Referencer til instansmetoder uden bestemt instans” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Java Academy-kurset, skal du opgradere til CoddyKit PRO. Java Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Referencer til instansmetoder uden bestemt instans”?

Referér til en instansmetode uden at angive modtageren – det bruges ofte sammen med Stream-operationer. Du øver dig i Java Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Java Academy?

Der kræves ingen tidligere erfaring. Java Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.

Hvor lang tid tager lektionen “Referencer til instansmetoder uden bestemt instans”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Java Academy-lektion?

Ja. Alle Java Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Referencer til statiske metoder
Referencer til instansmetoder på en bestemt instans
Referencer til instansmetoder uden bestemt instans
Konstruktørreferencer

← Tilbage til Java Academy