CodeGym /Kursy /JAVA 25 SELF /Method references (::): referencje do metod

Method references (::): referencje do metod

JAVA 25 SELF
Poziom 21, Lekcja 1
Dostępny

1. Wprowadzenie

Method reference (po polsku — referencja do metody) to specjalna składnia w Javie, pozwalająca przekazać już istniejącą metodę (lub konstruktor) jako implementację interfejsu funkcyjnego. Metodę można „przekazać” tam, gdzie oczekuje się wyrażenia lambda, jeśli sygnatury się zgadzają.

Składnia:

Klasa::metoda
obiekt::metoda
Klasa::new

Jeśli lambda to mini-funkcja „w locie”, to method reference to po prostu „przekaż już istniejącą metodę”. To jak wtedy, gdy zamiast przepisywać przepis, podajesz link do strony z przepisem.

Przykład na palcach

Zamiast tego:

list.forEach(s -> System.out.println(s));

Można tak:

list.forEach(System.out::println);

Wygląda zwięźle, prawda?

2. Rodzaje referencji do metod

Referencje do metod mają cztery podstawowe formy. Oto one — i nic więcej nie jest potrzebne.

Referencja do metody statycznej

Składnia: Klasa::statycznaMetoda

Przykład:

Function<Integer, String> intToString = String::valueOf;
System.out.println(intToString.apply(123)); // "123"

To samo za pomocą lambdy:

Function<Integer, String> intToString = i -> String.valueOf(i);

Referencja do niestatycznej metody obiektu

Składnia: obiekt::metoda

Przykład:

PrintStream printer = System.out;
Consumer<String> consumer = printer::println;
consumer.accept("Witaj, świecie!");

Równoważne lambdzie:

Consumer<String> consumer = s -> printer.println(s);

Referencja do niestatycznej metody klasy

Składnia: Klasa::metoda

Tutaj pierwszy parametr interfejsu funkcyjnego staje się obiektem, na którym wywoływana jest metoda.

Przykład:

Function<String, Integer> stringLength = String::length;
System.out.println(stringLength.apply("Java")); // 4

Tutaj String::length zamienia się w funkcję: (String s) -> s.length()

Referencja do konstruktora

Składnia: Klasa::new

Przykład:

Supplier<ArrayList<String>> listSupplier = ArrayList::new;
ArrayList<String> list = listSupplier.get();

Równoważne lambdzie:

Supplier<ArrayList<String>> listSupplier = () -> new ArrayList<>();

3. Kiedy używać referencji do metod?

Referencje do metod warto stosować, gdy lambda tylko wywołuje istniejącą metodę bez dodatkowej logiki — kod staje się wówczas krótszy i bardziej czytelny.

Przykład: sortowanie listy

Zamiast tego:

List<String> names = Arrays.asList("Jan", "Piotr", "Anna");
names.sort((a, b) -> a.compareToIgnoreCase(b));

Można tak:

names.sort(String::compareToIgnoreCase);

Przykład: przetwarzanie kolekcji

Zamiast:

list.forEach(s -> System.out.println(s));

Można jeszcze krócej:

list.forEach(System.out::println);

Przykład: przekształcanie elementów

Zamiast:

List<String> numbers = Arrays.asList("1", "2", "3");
List<Integer> ints = numbers.stream()
    .map(s -> Integer.parseInt(s))
    .collect(Collectors.toList());

Można:

List<Integer> ints = numbers.stream()
    .map(Integer::parseInt)
    .collect(Collectors.toList());

Więcej o Stream API i klasie narzędziowej Collectors poznasz na poziomie 30 :P

4. Porównanie referencji do metod i wyrażeń lambda

Równoważność

Referencja do metody i wyrażenie lambda często są wymienne. Oba realizują interfejs funkcyjny, jeśli sygnatury się zgadzają.

Przykład:

Consumer<String> c1 = s -> System.out.println(s);
Consumer<String> c2 = System.out::println;

Kiedy lepiej używać referencji do metod?

  • Gdy lambda tylko wywołuje istniejącą metodę bez dodatkowej logiki.
  • Dla poprawy czytelności, szczególnie przy długich łańcuchach wywołań.
  • Gdy chcesz wyraźnie pokazać: „tu jest tylko wywołanie metody”.

Kiedy referencja do metody nie pasuje?

  • Gdy potrzebna jest dodatkowa logika (walidacja, warunki, obsługa błędów).
  • Gdy parametry trzeba przekształcić przed wywołaniem metody.

Przykład:

list.forEach(s -> {
    if (s != null) System.out.println(s);
});
// Tutaj referencja do metody się nie sprawdzi, tylko lambda.

5. Praktyka: przepisujemy wyrażenia lambda z użyciem referencji do metod

Przykład 1: Wypisujemy nazwy zwierząt

List<String> animals = Arrays.asList("Kot", "Pies", "Papuga");
animals.forEach(animal -> System.out.println(animal));

Po zmianie:

animals.forEach(System.out::println);

Przykład 2: Przekształcamy napisy na liczby

List<String> numbers = Arrays.asList("10", "20", "30");
List<Integer> ints = numbers.stream()
    .map(s -> Integer.parseInt(s))
    .collect(Collectors.toList());

Po zmianie:

List<Integer> ints = numbers.stream()
    .map(Integer::parseInt)
    .collect(Collectors.toList());

Przykład 3: Sortowanie obiektów po nazwie

List<Animal> animalList = ...;
animalList.sort((a, b) -> a.getName().compareTo(b.getName()));

Po zmianie:

animalList.sort(Comparator.comparing(Animal::getName));

Tutaj Animal::getName — referencja do niestatycznej metody klasy.

Przykład 4: Tworzenie obiektów przez konstruktor

Supplier<Dog> dogFactory = () -> new Dog();
Dog dog = dogFactory.get();

Po zmianie:

Supplier<Dog> dogFactory = Dog::new;
Dog dog = dogFactory.get();

6. Jak działa dopasowanie sygnatur

Referencję do metody można wykorzystać tylko wtedy, gdy sygnatura metody pokrywa się z metodą abstrakcyjną interfejsu funkcyjnego.

@FunctionalInterface
interface IntToString {
    String convert(int value);
}

public class Demo {
    public static String intToHex(int value) {
        return Integer.toHexString(value);
    }

    public static void main(String[] args) {
        IntToString converter = Demo::intToHex;
        System.out.println(converter.convert(255)); // ff
    }
}

Tutaj Demo::intToHex pasuje, ponieważ przyjmuje int i zwraca String.

7. Referencje do metod a konstruktory z parametrami

Jeśli konstruktor przyjmuje parametry, referencji do metody nadal można użyć — o ile sygnatury się zgadzają.

@FunctionalInterface
interface AnimalFactory {
    Animal create(String name);
}

class Animal {
    private String name;
    public Animal(String name) { this.name = name; }
    public String getName() { return name; }
}

AnimalFactory factory = Animal::new;
Animal cat = factory.create("Whity");
System.out.println(cat.getName()); // Whity

8. Typowe błędy przy użyciu referencji do metod

Błąd nr 1: Niezgodność sygnatur.
Jeśli sygnatura metody nie pokrywa się z metodą abstrakcyjną interfejsu, kompilator zgłosi błąd. Na przykład interfejs oczekuje dwóch parametrów, a referencja wskazuje na metodę z jednym parametrem.

Błąd nr 2: Próba użycia referencji do niestatycznej metody klasy bez obiektu.
Gdy używasz formy Klasa::metoda, pierwszy parametr interfejsu staje się obiektem wywołania. Jeśli pomylisz liczbę lub kolejność parametrów — dostaniesz błąd dopasowania.

Błąd nr 3: Użycie referencji do metody tam, gdzie potrzebna jest dodatkowa logika.
Jeśli wymagany jest warunek, logowanie lub obsługa wyjątków — użyj lambdy, a nie referencji do metody.

Błąd nr 4: Referencje do przeciążonych metod.
Jeśli klasa ma kilka metod o tej samej nazwie, kompilator może nie wiedzieć, którą wybrać. Czasem pomaga jawne wskazanie typu interfejsu funkcyjnego.

Błąd nr 5: Użycie referencji do niestatycznej metody bez obiektu.
Na przykład String::toUpperCase działa poprawnie w map, ponieważ pierwszy parametr to sam obiekt String. Ale poza odpowiednim kontekstem, gdzie oczekuje się metody statycznej, doprowadzi to do błędu.

1
Zadanie
JAVA 25 SELF, poziom 21, lekcja 1
Niedostępne
Konwerter identyfikatorów urządzeń 📟
Konwerter identyfikatorów urządzeń 📟
1
Zadanie
JAVA 25 SELF, poziom 21, lekcja 1
Niedostępne
Własny system logowania 📝
Własny system logowania 📝
1
Zadanie
JAVA 25 SELF, poziom 21, lekcja 1
Niedostępne
Organizacja inwentarza w magazynie 🍎🍌🍐
Organizacja inwentarza w magazynie 🍎🍌🍐
1
Zadanie
JAVA 25 SELF, poziom 21, lekcja 1
Niedostępne
Fabryka wirtualnych pupili 🐾
Fabryka wirtualnych pupili 🐾
Komentarze
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION