Java Academy · Lektion

Referencer til statiske metoder

Erstat lambdaer, der kalder statiske metoder, med ClassName::methodName-referencer.

Lektion 1 af 413 trin

Referencer til statiske metoder er en gratis Java Academy-lektion på CoddyKit. Dette er lektion 1 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 metodereferencer?

En metodereference er en kortere form af et lambdaudtryk, som videredelegerer til en eksisterende metode. Når et lambdaudtryk blot kalder én metode, er en metodereference renere og mere læsbar.

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 statiske metodereferencer

En statisk metodereference har formen ClassName::staticMethodName. Den kan bruges alle steder, hvor et funktionelt interface 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 metodereference

Statiske metoder fra hjælpeklasser 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 metodereference med Predicate

Statiske metoder, der returnerer en boolsk værdi, kan bruges 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-reference

Statiske metoder, der passer til 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]

Brugerdefineret statisk hjælpemetode

Definér en statisk hjælpemetode, og referér direkte til den:

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 en statisk metode

Statiske metoder, der tager to parametre, kan passe til 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 reference

Kombinér Comparator.comparing med metodereferencer for at opnå en overskuelig 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

Hvornår skal du bruge statiske metodereferencer?

Brug statiske metodereferencer, når:

Lambdaudtrykkets krop er ét enkelt kald til en statisk metode
Argumenterne ikke skal transformeres
Metodens signatur passer til det funktionelle interface

Hvis du skal transformere argumenter eller tilføje logik, skal du i stedet bruge et lambdaudtryk.

Sammenligning af læsbarhed

Side-om-side-sammenligning af lambda- og metodereferenceformater:

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

Almindelig faldgrube: Forkert signatur

En metodereference fungerer kun, hvis dens signatur passer præcist til det funktionelle interfaces abstrakte metode. Hvis argumenttyperne eller antallet af argumenter er forskellige, skal du i stedet bruge et lambdaomslag.

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

Hurtigt tjek

Hvilken af følgende er en gyldig statisk metodereference, der fungerer som en Predicate<Object>?

Besvar den i den interaktive lektion

Opsummering: Statiske metodereferencer

Vigtigste pointer:

Syntaks: ClassName::staticMethodName
Erstatter lambdaudtryk, der videredelegerer til én enkelt statisk metode
Metodens signatur skal passe til det funktionelle interfaces abstrakte metode
Fungerer med Predicate, Function, Consumer, Comparator osv.
Brug lambdaudtryk, når argumenter skal transformeres, eller der er brug for ekstra logik

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 statiske metoder” gratis?

Ja — hele teksten til “Referencer til statiske metoder” 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 statiske metoder”?

Erstat lambdaer, der kalder statiske metoder, med ClassName::methodName-referencer. 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 1 af 4.

Hvor lang tid tager lektionen “Referencer til statiske metoder”?

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