Statische Imports in Java nutzen: ja oder nein?

Kommt drauf an – aber worauf eigentlich?

Meiner Ansicht nach ist ausschlaggebend, ob der statische Import den Lesefluss verbessert. Wann immer das der Fall ist, solltest du den statischen Import verwenden.

Code wird viel öfter gelesen als geschrieben. Deshalb ist es essenziell, dass du beim Schreiben auf die Lesbarkeit zu achtest. Ein Stilmittel, das du in Java zu diesem Zweck verwenden kannst, sind die statischen Imports.

Damit das Ganze nicht so abstrakt bleibt, möchte ich es mit ein paar Beispielen veranschaulichen.

Welche der beiden Varianten ist zu bevorzugen?

var myList = List.of("a", "b", "c");

oder

var myList = of("a", "b", "c");

Sicherlich a). Hier entspricht der Lesefluss eher der gesprochenen Sprache; der Code liest sich in etwa wie »Variable myList = List of „a“, „b“ and „c“«. Bei Variante b) dagegen komme ich ins Stolpern, weil irgendetwas fehlt.

Anders dagegen sieht es mit der Methode Arrays.asList(...) aus, die quasi dasselbe macht, und aus der Zeit stammt, als es List.of(...) noch nicht gab:

var myList = Arrays.asList("a", "b", "c");

oder

var myList = asList("a", "b", "c");

Hier bevorzuge ich Variante b), weil das „Arrays“ den Lesefluss stört. Es gibt mir zwar die zusätzliche Information, dass die Methode aus der Klasse Arrays stammt, aber beim Lesen des Codes ist mir das schnelle Verständnis wichtiger als diese Information. Einigermaßen erfahrenen Entwicklern dürfte das ohnehin bekannt sein, und falls nicht, ist die Information in modernen Entwicklungsumgebungen per Tastenkürzel oder Mausklick einfach verfügbar.

Wie sieht es hiermit aus?

var date = LocalDate.of(2022, 2, 2);

oder

var date = of(2022, 2, 2);

Hier würde ich wiederum a) wählen, aus demselben Grund wie im ersten Beispiel.

Schauen wir ein Beispiel aus der Stream-API an:

var myList = someList.stream()
    // ... (some stream operations)
   .collect(Collectors.toList());

oder

var myList = someList.stream()
    // ... (some stream operations)
   .collect(toList());

Auch hier entscheide ich mich für Variante b), die sich am Ende liest wie »Collect to list«. Für a) gilt dasselbe wie im vorangehenden Beispiel, hier stört das redundante Collectors. Oder noch besser: Wenn ich Java Version 16 oder höher verwenden kann, nutze ich Stream#toList(), ohne den Umweg über die Collectors-Klasse:

var myList = someList.stream()
    // ... (some stream operations)
   .toList();

„Sprechende“ APIs

Viele moderne APIs sind heutzutage so gestaltet, dass ihre Verwendung zu gut lesbarem Code führt. Auch in der Java-Standardbibliothek sind Beispiele dafür zu finden. Statische Imports spielen dort manchmal ebenfalls eine Rolle:

myList.sort(Comparator.comparing(String::length));

oder

myList.sort(comparing(String::length));

Auch hier lässt sich b) wieder schön lesen wie »myList sort comparing String length« –  auf jeden Fall besser als a) mit dem redundanten Comparator.comparing(...).

Noch ein letztes Beispiel, dann hast du’s geschafft. :-) Hier wollen wir die Strings aus der Liste in eine Map überführen, in der die Keys die Stringlänge, und die Values Listen aller Strings mit der jeweiligen Länge sind:

var myList = asList("a", "bb", "cc", "ddd", "eee");
var byLength = myList.stream()
   .collect(Collectors.groupingBy(String::length));

oder

var myList = asList("a", "bb", "cc", "ddd", "eee");
var byLength = myList.stream()
   .collect(groupingBy(String::length));

Muss ich noch was sagen? :-)

Wähle statische Imports immer dann, wenn du damit den Lesefluss deines Codes verbessern kannst. Am besten probierst du beide Varianten aus, und sprichst diese leise vor dich hin. Dann wirst du selbst merken, welche davon eher der natürlich gesprochenen Sprache entspricht. Für diese entscheidest du dich dann.

Als Daumenregel könnte man sagen, dass Methoden aus „sprechenden APIs“ ohne die Klasse geschrieben werden (z.B. toList(), groupingBy() etc.), statische Fabrikmethoden wie „of(...), from(...)“ u.ä. dagegen mit der Klasse. Im Einzelfall sollten jedoch der Lesefluss und die Verständlichkeit des Codes den Ausschlag geben.

Mehr zu Java Programmierung erfahren