12.2    Methodenreferenz 

 

12.2.1    Motivation 

Je größer Softwaresysteme werden, desto wichtiger werden Dinge wie Klarheit, Wiederverwendbarkeit und Dokumentation. Wir haben für unseren String-Comparator eine Implementierung geschrieben, anfangs über eine innere Klasse, später über einen Lambda-Ausdruck. In jedem Fall haben wir Code geschrieben. Doch was wäre, wenn eine Utility-Klasse schon eine Implementierung mitbringen würde? Dann könnte der Lambda-Ausdruck natürlich an die vorhandene Implementierung delegieren, und wir sparen Code. Schauen wir uns das an einem Beispiel an:

Listing 12.10    src/main/java/com/tutego/insel/lambda/TrimCompareWithDelegation.java, Ausschnitt

class StringUtils {

  public static int trimCompare( String s1, String s2 ) {

    return s1.trim().compareTo( s2.trim() );

  } 

}

public class TrimCompareWithDelegation {

  public static void main( String[] args ) {

    String[] words = { "A", "B", "a" };

    Arrays.sort( words,

                 (String s1, String s2) -> StringUtils.trimCompare(s1, s2) );

    System.out.println( Arrays.toString( words ) );

  }

}

 

12.2.2    Methodenreferenzen mit :: 

Auffällig im Beispiel ist, dass die referenzierte Methode int trimCompare(String, String) von den Parametertypen und vom Rückgabetyp genauso wie int compare(String, String) ist und – wenn wir den Methodennamen wegelassen – wie die Methode im Comparator funktioniert. Für genau solche Fälle gibt es eine weitere syntaktische Verkürzung.

Die Zeile

Arrays.sort( words, (String s1, String s2) -> StringUtils.trimCompare(s1, s2) );

lässt sich mit einer Methodenreferenz abkürzen zu:

Arrays.sort( words, StringUtils::trimCompare );

Im Code steht kein Lambda-Ausdruck mehr, sondern nur noch ein Methodenverweis. Die Sortiermethode erwartet vom Comparator eine Methode, die zwei Strings annimmt und eine Ganzzahl zurückgibt. Der Name der Klasse und der Name der Methode sind unerheblich, weshalb an dieser Stelle eine Methodenreferenz eingesetzt werden kann.

Eine Methodenreferenz ist wie ein Lambda-Ausdruck ein Exemplar einer funktionalen Schnittstelle, jedoch für eine existierende Methode einer bekannten Klasse. Wie üblich bestimmt der Kontext, von welchem Typ genau der Ausdruck ist.

Comparator<String>                c1 = StringUtils::trimCompare;

BiFunction<String,String,Integer> c2 = StringUtils::trimCompare;

 

12.2.3    Varianten von Methodenreferenzen 

Im Beispiel ist die Methode trimCompare(…) statisch, und links vom Doppelpunkt steht der Name eines Typs. Das ist jedoch nicht der einzige Anwendungsfall – ingesamt gibt es drei Varianten für Methodenreferenzen:

Tabelle 12.6    Unterschiedliche Methodenreferenzen

param in Tabelle 12.6 kann für mehr als einen Parameter stehen, auch für keinen. In der Schreibweise für die Methodenreferenz tauchen Parameter nicht auf.

Methodenreferenz auf eine statische Methode

System.currentTimeMillis() liefert ein long mit den Millisekunden seit dem 1.1.1970, 0 Uhr. Das ist auch ein Supplier:

Supplier<Long> time = System::currentTimeMillis;

Math.max(…) ist eine statische Methode, bei der zwei Elemente auf das Maximum reduziert werden. Das ist auch das, was eine BiFunction macht. Daher gilt:

BiFunction<Integer, Integer, Integer> max = Math::max;

Ist eine Hauptmethode in der Klasse JavaApplication mit main(String... args) deklariert, so ist das auch ein Runnable:

Runnable r = JavaApplication::main;

Anders wäre das bei main(String[]): Hier ist ein Parameter zwingend, doch ein Vararg kann auch leer sein.

Methodenreferenz auf eine Objektmethode

System.out ist eine Referenz, und eine Methode wie println(…) kann an einen Consumer gebunden werden. Es ist aber auch ein Runnable, weil es println() auch ohne Parameterliste gibt:

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

out.accept( "Kates kurze Kleider" );

Runnable out = System.out::println;          // () -> System.out.println()

out.run();

Methodenreferenz auf eine Objektmethode eines Typs

Die String-Methode isEmpty() liefert true, wenn der String leer ist, sonst false. Das ist wie ein Predicate. Wir können String::isEmpty statt s -> s.isEmpty() nutzen.

String::length ist ein weiteres Beispiel. Das wäre eine Funktion, die ein String auf ein int abbildet. In Code sieht das so aus: Function<String,Integer> len = String::length.

Um einfach ein Comparator-Objekt aufzubauen, können wir Schlüssel-Extraktoren einsetzen. Diese benötigen eine Funktion (Generics verkürzt):

static <…> Comparator<…> comparing(Function<…> keyExtractor)

Nehmen wir an, wir haben eine Klasse Person und eine Methode getName(). Holen wir die Daten über einen Getter, können wir statt p -> p.getName() die Methodenreferenz Person::getName nutzen.

this und super sind möglich

Anstatt den Namen einer Referenzvariablen zu wählen, kann auch this das Objekt beschreiben, und auch super ist möglich. this ist praktisch, wenn die Implementierung einer funktionalen Schnittstelle auf eine Methode der eigenen Klasse delegieren möchte. Wenn zum Beispiel eine lokale Methode trimCompare(…) in der Klasse existieren würde, in der auch der Lambda-Ausdruck steht, und wenn diese Methode als Comparator in Arrays.sort(…) verwendet werden sollte, könnte es heißen: Arrays.sort(words, this::trimCompare).

Einschränkungen

Es ist nicht möglich, eine spezielle (überladene) Methode über die Methodenreferenz auszuwählen. Eine Angabe wie String::valueOf oder Arrays::sort ist relativ breit – bei Letzterem wählt der Compiler eine der 18 passenden überladenen Methoden aus. Da kann es passieren, dass der Compiler eine falsche Methode auswählt. In dem Fall muss ein expliziter Lambda-Ausdruck eine Mehrdeutigkeit auflösen. Bei generischen Typen kann zum Beispiel List<String>::length oder auch List::length stehen. Auch hier erkennt der Compiler wieder alles selbst.

Was soll das alles?

Einem Einsteiger in die Sprache Java wird dieses Sprach-Feature wie der größte Zauber auf Erden vorkommen, und auch Java-Profis bekommen hier zittrige Finger, entweder vor Furcht oder vor Aufregung. In der Vergangenheit musste in Java sehr viel Code explizit geschrieben werden, aber mit diesen neuen Methodenreferenzen erkennt und macht der Compiler vieles von selbst.

Nützlich wird diese Eigenschaft mit den funktionalen Bibliotheken bei der Stream-API, die ein eigenes Kapitel in meinem Buch »Java SE 9 Standard-Bibliothek« einnehmen. Hier nur ein kurzer Vorgeschmack:

Object[] words = { " ", '3', null, "2", 1, "" };

Arrays.stream( words )                   // " ", '3', null, "2", 1, ""

      .filter( Objects::nonNull )        // " ", '3', "2", 1, ""

      .map( Objects::toString )          // " ", "3", "2", "1", ""

      .map( String::trim )               // "", "3", "2", "1", ""

      .filter( s -> ! s.isEmpty() )      // "3", "2", "1"

      .map( Integer::parseInt )          // 3, 2, 1

      .sorted()                          // 1, 2, 3

      .forEach( System.out::println );   // 1 2 3