Java - Method References (Deutsch)

Hallo dort, aufstrebende Java-Programmierer! Heute werden wir in ein faszinierendes Thema eintauchen, das vielleicht am Anfang ein bisschen abschreckend klingt, aber ich verspreche euch, dass ihr es unglaublich nützlich finden werdet, sobald ihr es beherrscht. Wir sprechen über Methodenreferenzen in Java. Also, holt euch euer Lieblingsgetränk, macht euch bequem und lass uns gemeinsam auf diese aufregende Reise aufbrechen!

Was sind Methodenreferenzen?

Bevor wir in die Details einsteigen, beginnen wir mit einer einfachen Frage: Was genau sind Methodenreferenzen? Stellt euch vor, ihr hättet einen Freund, der wirklich gut in der Kuchenbackerei ist. Anstatt jedes Mal die ganze Rezeptur zu erklären, wenn ihr Kekse wollt, könntest ihr einfach sagen: "Mach das, was du mit den Keksen machst." Das ist im Grunde genommen, was eine Methode in Java ist – eine Abkürzung, um auf eine Methode zu verweisen, ohne sie wirklich auszuführen.

Methodenreferenzen wurden in Java 8 als Teil der Lambda-Ausdrücke-Funktion eingeführt. Sie bieten eine Möglichkeit, auf Methoden oder Konstruktoren zu verweisen, ohne sie aufzurufen. Es ist wie auf eine Methode zu zeigen und zu sagen: "Benutze das, wenn du es brauchst."

Arten von Java-Methodenreferenzen

Jetzt, da wir eine grundlegende Verständnis haben, untersuchen wir die verschiedenen Arten von Methodenreferenzen. Es gibt vier Hauptarten:

1. Verweis auf eine statische Methode
2. Verweis auf eine Instanzmethode eines bestimmten Objekts
3. Verweis auf eine Instanzmethode eines beliebigen Objekts eines bestimmten Typs
4. Verweis auf einen Konstruktor

Lassen Sie uns jeden dieser Typen mit einigen Codebeispielen detailliert ansehen.

1. Methodeferenz für statische Methode

Dies ist wahrscheinlich der einfachste Typ zu verstehen. Es handelt sich um den Verweis auf eine statische Methode in einer Klasse. Hier ist ein Beispiel:

import java.util.Arrays;
import java.util.List;

public class StaticMethodReference {
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

// Verwenden von Lambda-Ausdruck
numbers.forEach(number -> System.out.println(number));

// Verwenden von Methodeferenz
numbers.forEach(System.out::println);
}
}

In diesem Beispiel ist System.out::println eine Methodenreferenz zur statischen Methode println des System.out-Objekts. Es ist äquivalent zum Lambda-Ausdruck number -> System.out.println(number), aber es ist kürzer und lesbarer.

2. Methodeferenz für Instanzmethode eines bestimmten Objekts

Dieser Typ der Methodenreferenz wird verwendet, wenn wir auf eine Instanzmethode eines bestehenden Objekts verweisen möchten. Sehen wir uns ein Beispiel an:

public class InstanceMethodReference {
public void printUpperCase(String s) {
System.out.println(s.toUpperCase());
}

public static void main(String[] args) {
InstanceMethodReference imr = new InstanceMethodReference();
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

// Verwenden von Lambda-Ausdruck
names.forEach(name -> imr.printUpperCase(name));

// Verwenden von Methodeferenz
names.forEach(imr::printUpperCase);
}
}

Hier ist imr::printUpperCase eine Methodenreferenz zur Methode printUpperCase des imr-Objekts. Es ist äquivalent zum Lambda-Ausdruck name -> imr.printUpperCase(name).

3. Methodeferenz für Instanzmethode eines beliebigen Objekts eines bestimmten Typs

Dies ist ein bisschen trickreicher, aber bleibt dran! Dieser Typ der Methodenreferenz wird verwendet, wenn wir eine Methode eines beliebigen Objekts eines bestimmten Typs aufrufen möchten. Hier ist ein Beispiel:

import java.util.Arrays;
import java.util.List;

public class ArbitraryObjectMethodReference {
public static void main(String[] args) {
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

// Verwenden von Lambda-Ausdruck
names.sort((s1, s2) -> s1.compareToIgnoreCase(s2));

// Verwenden von Methodeferenz
names.sort(String::compareToIgnoreCase);
}
}

In diesem Beispiel ist String::compareToIgnoreCase eine Methodenreferenz zur Methode compareToIgnoreCase der Klasse String. Es ist äquivalent zum Lambda-Ausdruck (s1, s2) -> s1.compareToIgnoreCase(s2).

4. Methodeferenz für Konstruktor

Schließlich, aber nicht zuletzt, können wir auch Methodenreferenzen verwenden, um auf Konstruktoren zu verweisen. So funktioniert das:

import java.util.function.Supplier;

class Person {
private String name;

public Person() {
this.name = "Unbekannt";
}

public String getName() {
return name;
}
}

public class ConstructorMethodReference {
public static void main(String[] args) {
// Verwenden von Lambda-Ausdruck
Supplier<Person> personSupplier1 = () -> new Person();

// Verwenden von Konstruktorreferenz
Supplier<Person> personSupplier2 = Person::new;

Person person1 = personSupplier1.get();
Person person2 = personSupplier2.get();

System.out.println(person1.getName());  // Ausgabe: Unbekannt
System.out.println(person2.getName());  // Ausgabe: Unbekannt
}
}

In diesem Beispiel ist Person::new eine Methodenreferenz zum Konstruktor der Klasse Person. Es ist äquivalent zum Lambda-Ausdruck () -> new Person().

Warum Methodenreferenzen verwenden?

Nun könnt ihr euch fragen: "Warum sollte ich mich mit Methodenreferenzen abmühen, wenn ich einfach Lambda-Ausdrücke verwenden kann?" Geile Frage! Hier sind einige Gründe:

1. Lesbarkeit: Methodenreferenzen machen den Code oft lesbarer und knapper.
2. Wiederverwendbarkeit: Sie ermöglichen es, bestehende Methodenimplementierungen zu wiederverwenden.
3. Leistung: In einigen Fällen können Methodenreferenzen etwas effizienter als Lambda-Ausdrücke sein.

Fazit

Und so haben wir das, Freunde! Wir haben die Grundlagen der Methodenreferenzen in Java abgedeckt. Bedenkt, dass es wie das Lernen eines neuen Konzepts sein kann, vielleicht etwas Übung erfordert, um sich an Methodenreferenzen zu gewöhnen. Aber sobald ihr es geschafft habt, werdet ihr finden, dass sie euren Code sauberer und ausdrucksstärker machen können.

Wenn wir jetzt zusammenfassen, möchte ich euch eine kleine Geschichte aus meiner Lehrerfahrung erzählen. Ich hatte einmal einen Schüler, der mit Methodenreferenzen zu kämpfen hatte. Er sagte immer: "Es ist, als ob ich auf etwas zeigen möchte, ohne meinen Finger zu verwenden!" Aber nach etwas Übung hatte er einen "Aha!"-Augenblick und rief aus: "Jetzt verstehe ich es! Es ist, als ob man eine Fernbedienung verwendet, anstatt jedes Mal zum Fernseher zu gehen!" Und genau das ist es – Methodenreferenzen sind wie kleine Fernbedienungen für deine Methoden.

Also, lasst weiter programmieren, üben und vor allem, habt Spaß mit Java! Bedenkt, dass jeder Meister einmal ein Anfänger war. Happy coding!

Credits: Image by storyset