Java Academy · leksjon

Referanser til statiske metoder

Erstatt lambda-uttrykk som kaller statiske metoder, med ClassName::methodName-referanser.

Leksjon 1 av 413 trinn

Referanser til statiske metoder er en gratis leksjon i Java Academy på CoddyKit. Dette er leksjon 1 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Java Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Java Academy inneholder totalt 4 leksjoner.

Hva er metodereferanser?

En metodereferanse er en kortform av en lambda som delegerer til en eksisterende metode. Når en lambda bare ville kalt én enkelt metode, er en metodereferanse renere og mer lesbar.

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

List<String> names = List.of("Alice", "Bob", "Carol");

// Lambda:
names.forEach(s -> System.out.println(s));

// Equivalent method reference:
names.forEach(System.out::println);

Syntaks for statisk metodereferanse

En statisk metodereferanse har formen ClassName::staticMethodName. Den kan brukes overalt der et funksjonelt grensesnitt forventer en metode med samme signatur.

import java.util.stream.*;

// Integer.parseInt(String) matches Function<String, Integer>
List<String> strs = List.of("1","2","3","4","5");
List<Integer> nums = strs.stream()
    .map(Integer::parseInt)  // replaces s -> Integer.parseInt(s)
    .collect(Collectors.toList());
System.out.println(nums); // [1, 2, 3, 4, 5]

Math.abs som metodereferanse

Statiske metoder fra hjelpeklasser som Math kan refereres direkte:

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

List<Integer> values = List.of(-3, 5, -1, 8, -4);
List<Integer> abs = values.stream()
    .map(Math::abs)  // replaces v -> Math.abs(v)
    .collect(Collectors.toList());
System.out.println(abs); // [3, 5, 1, 8, 4]

Statisk metodereferanse med Predicate

Statiske metoder som samsvarer med en boolsk returverdi, kan brukes som Predicate:

import java.util.stream.*;

// String.isEmpty() is an instance method, but we can use a static helper
// Objects.isNull matches Predicate<Object>
List<String> mixed = Arrays.asList("hello", null, "world", null);
long nullCount = mixed.stream()
    .filter(Objects::isNull)
    .count();
System.out.println(nullCount); // 2

long nonNull = mixed.stream()
    .filter(Objects::nonNull)
    .count();
System.out.println(nonNull); // 2

Statisk Comparator-referanse

Statiske metoder som samsvarer med Comparator, kan også refereres:

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

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

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

Egendefinert statisk hjelpemetode

Definer en statisk hjelpemetode og referer til den direkte:

class Validator {
    static boolean isPositive(int n) { return n > 0; }
    static String toLabel(int n) { return n > 0 ? "POS" : "NEG"; }
}

List<Integer> nums = List.of(-2, 3, -1, 5, 0);

List<Integer> positive = nums.stream()
    .filter(Validator::isPositive)
    .collect(Collectors.toList());
System.out.println(positive); // [3, 5]

List<String> labels = nums.stream()
    .map(Validator::toLabel)
    .collect(Collectors.toList());

BiFunction med statisk metode

Statiske metoder som tar to parametere, kan samsvare med BiFunction<T,U,R>:

import java.util.function.*;

// Math.max(int,int) → BiFunction... but needs IntBinaryOperator
java.util.function.IntBinaryOperator maxOp = Math::max;
System.out.println(maxOp.applyAsInt(7, 3)); // 7

// String.format as BiFunction? Only works if signature matches:
// Integer.sum(int,int) → IntBinaryOperator
java.util.function.IntBinaryOperator sum = Integer::sum;
System.out.println(sum.applyAsInt(10, 20)); // 30

Sortering med Comparator.comparing + statisk referanse

Kombiner Comparator.comparing med metodereferanser for ryddig sortering:

record Person(String name, int age) {}
List<Person> people = List.of(
    new Person("Charlie",30), new Person("Alice",25), new Person("Bob",35)
);

people.stream()
    .sorted(Comparator.comparing(Person::name))
    .forEach(p -> System.out.println(p.name()));
// Alice, Bob, Charlie

Når bør du bruke statiske metodereferanser?

Bruk statiske metodereferanser når:

Lambdauttrykket består av ett enkelt kall til en statisk metode
Ingen transformasjon av argumentene er nødvendig
Metodesignaturen samsvarer med det funksjonelle grensesnittet

Hvis du må transformere argumenter eller legge til logikk, bør du bruke en lambda.

Sammenligning av lesbarhet

Sammenligning side ved side av lambda- og metodereferansestil:

// Lambda style
Stream.of("1","2","3").map(s -> Integer.parseInt(s));
Stream.of(1,-2,3).filter(n -> n > 0);
Stream.of(-5,2,-1).map(n -> Math.abs(n));

// Method reference style
Stream.of("1","2","3").map(Integer::parseInt);
Stream.of(1,-2,3).filter(Validator::isPositive);
Stream.of(-5,2,-1).map(Math::abs);

Vanlig fallgruve: Feil signatur

En metodereferanse fungerer bare hvis signaturen samsvarer nøyaktig med den abstrakte metoden i det funksjonelle grensesnittet. Hvis argumenttypene eller antallet argumenter er forskjellig, bør du bruke en lambda-innpakning i stedet.

// Math.pow(double, double) needs two args — can't use as Function<Double, Double>
// This won't compile:
// Function<Double, Double> square = Math::pow; // ERROR

// Fix with lambda:
Function<Double, Double> square = n -> Math.pow(n, 2);
System.out.println(square.apply(5.0)); // 25.0

Hurtigsjekk

Hvilken av de følgende er en gyldig statisk metodereferanse som fungerer som en Predicate<Object>?

Besvar den i den interaktive leksjonen

Oppsummering: Statiske metodereferanser

Viktigste punkter:

Syntaks: ClassName::staticMethodName
Erstatter lambdauttrykk som delegerer til én enkelt statisk metode
Metodesignaturen må samsvare med den abstrakte metoden i det funksjonelle grensesnittet
Fungerer med Predicate, Function, Consumer, Comparator og andre
Bruk lambdauttrykk når argumenttransformasjon eller ekstra logikk er nødvendig

Gratis å komme i gang

Lær deg Java med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 104
Leksjoner: 374

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Referanser til statiske metoder» gratis?

Ja – hele teksten i «Referanser til statiske metoder» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Java Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Java Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Referanser til statiske metoder»?

Erstatt lambda-uttrykk som kaller statiske metoder, med ClassName::methodName-referanser. Du øver på Java Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Java Academy?

Ingen tidligere erfaring er nødvendig. Java Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.

Hvor lang tid tar leksjonen «Referanser til statiske metoder»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Java Academy-leksjonen?

Ja. Alle Java Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Referanser til statiske metoder
Metodereferanser til instansmetoder på en bestemt instans
Metodereferanser til vilkårlige instanser
Konstruktørreferanser

← Tilbake til Java Academy