In diesem Artikel erf\u00e4hrst du:<\/p>\n\n\n\n
import module<\/code> ganze Java-Module importiert werden?<\/li>\n\n\n\n- Wie k\u00f6nnen dabei Mehrdeutigkeiten aufgel\u00f6st werden?<\/li>\n\n\n\n
- Was sind transitive Modul-Importe, und wie funktionieren sie?<\/li>\n\n\n\n
- Welche Module werden standardm\u00e4\u00dfig importiert?<\/li>\n<\/ul>\n\n\n\n
Beginnen wir mit einem ganz kurzen R\u00fcckblick...<\/p>\n\n\n\n
Java Imports<\/h2>\n\n\n\n
Seit Java 1.0 k\u00f6nnen wir mit dem import<\/code>-Statement einzelne Klassen (\u201esingle-type-import declaration\u201c) oder ganze Pakete (\u201etype-import-on-demand declaration\u201c) importieren, z. B. wie folgt:<\/p>\n\n\nimport<\/span> java.util.*;\nimport<\/span> java.util.stream.Stream;<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\nDie Klassen des Pakets java.lang<\/code> werden seit jeher automatisch importert. Deshalb m\u00fcssen wir f\u00fcr Klassen wie Object<\/code>, String<\/code>, Integer<\/code>, Exception<\/code>, usw. keine import<\/code>-Statements angeben.<\/p>\n\n\n\nModule Import Declarations<\/h2>\n\n\n\n
Mit import module<\/code> k\u00f6nnen wir ab Java 25<\/a> (und in Java 23<\/a> und Java 24<\/a> im Preview-Modus) auch ganze Module importieren. Dadurch k\u00f6nnen wir alle Klassen, die sich innerhalb eines Moduls befinden und von diesem exportiert werden, direkt verwenden.<\/p>\n\n\n\nIm folgenden Beispiel importieren wir das Modul java.base<\/code> und k\u00f6nnen dadurch die Klassen List<\/code>, Map<\/code>, Stream<\/code> und Collectors<\/code> verwenden, ohne sie einzeln oder paketweise importieren zu m\u00fcssen (String<\/code> und Character<\/code> liegen im Paket java.lang<\/code> und wurden daher schon immer automatisch importiert).<\/p>\n\n\nimport<\/span> module<\/span> java.base;\n\npublic<\/span> class<\/span> ModuleImportTest<\/span> <\/span>{\n\n public<\/span> static<\/span> Map<Character, List<String>> groupByFirstLetter(String... values) {\n return<\/span> Stream.of(values).collect(\n Collectors.groupingBy(s -> Character.toUpperCase(s.charAt(0<\/span>))));\n }\n}<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\nWenn du dieses Code-Beispiel in der Datei ModuleImportTest.java<\/em> speicherst, kannst du die Klasse im aktuellen Java 24 wie folgt kompilieren (in Java 23 musst du den Parameter --source 24<\/code> durch --source 23<\/code> ersetzen; in Java 25 k\u00f6nnen --enable-preview<\/code> und --source<\/code> wegfallen):<\/p>\n\n\njavac --enable-preview --source 24 ModuleImport.java<\/code><\/span>Code-Sprache:<\/span> Klartext<\/span> (<\/span>plaintext<\/span>)<\/span><\/small><\/pre>\n\n\nUm import module<\/code> zu verwenden ist es \u2013 wie im vorangegangenen Beispiel gesehen \u2013 nicht n\u00f6tig, dass sich die importierende Klasse selbst in einem Modul befindet.<\/p>\n\n\n\nCompact Source Files<\/a> (zuvor bekannt als \u201eImplizit deklarierte Klassen\u201c und \u201esimple source files\u201c) und JShell importieren automatisch das java.base<\/code>-Modul, d. h. Klassen wie List<\/code> und Map<\/code> kannst du dort ohne explizite Imports verwenden.<\/p>\n\n\n\nMehrdeutige Klassennamen<\/h2>\n\n\n\n
Manchmal kommt es vor, dass ein Klassenname nicht eindeutig ist. In folgendem Beispiel gibt es eine List<\/code>-Klasse sowohl im importierten Modul java.base<\/code> (java.util.List<\/code>) als auch im Modul java.desktop<\/code> (java.awt.List<\/code>):<\/p>\n\n\nimport<\/span> module<\/span> java.base; \/\/ \u2190 Contains java.util.List<\/span>\nimport<\/span> module<\/span> java.desktop; \/\/ \u2190 Contains java.awt.List<\/span>\n\npublic<\/span> class<\/span> Ambiguous<\/span> <\/span>{\n List list; \/\/ \u2190 Ambiguous reference to List<\/span>\n}<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\nWenn du die Datei unter Ambiguous.java<\/em> abspeicherst und dann wie folgt mit Java 24 kompilierst:<\/p>\n\n\njavac --enable-preview --source 24 Ambiguous.java<\/code><\/span>Code-Sprache:<\/span> Klartext<\/span> (<\/span>plaintext<\/span>)<\/span><\/small><\/pre>\n\n\n... oder wie folgt mit Java 23:<\/p>\n\n\n
javac --enable-preview --source 23 Ambiguous.java<\/code><\/span>Code-Sprache:<\/span> Klartext<\/span> (<\/span>plaintext<\/span>)<\/span><\/small><\/pre>\n\n\n... dann bricht der Compiler mit folgender Fehlermeldung ab:<\/p>\n\n\n
Ambiguous.java:5: error: reference to List is ambiguous\n List list;\n ^\n both class java.awt.List in java.awt and interface java.util.List in java.util match<\/code><\/span>Code-Sprache:<\/span> Klartext<\/span> (<\/span>plaintext<\/span>)<\/span><\/small><\/pre>\n\n\nDas bedeutet, dass der Compiler nicht wei\u00df, welche der beiden List<\/code>-Klassen gemeint ist.<\/p>\n\n\n\nMehrdeutige Klassennamen aufl\u00f6sen<\/h3>\n\n\n\n
Nehmen wir an, du m\u00f6chtest java.util.List<\/code> verwenden (und nicht java.awt.List<\/code>). Dann hast du zwei M\u00f6glichkeiten, um diese Mehrdeutigkeit aufzul\u00f6sen:<\/p>\n\n\n\nOption 1: Du importierst zus\u00e4tzlich die Klasse java.util.List<\/code> direkt:<\/p>\n\n\nimport<\/span> module<\/span> java.base;\nimport<\/span> module<\/span> java.desktop;\n\nimport<\/span> java.util.List; \/\/ \u2190 Ambiguity resolved by single-type-import declaration<\/span>\n\npublic<\/span> class<\/span> Ambiguous<\/span> <\/span>{\n List list;\n}<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\nOption 2: Du importierst zus\u00e4tzlich das Paket java.util<\/code> (in der Java-Terminologie hei\u00dft das \u00fcbrigens nicht \u201ePackage Import\u201c sondern \u201eType-Import-on-Demand Declaration\u201c):<\/p>\n\n\nimport<\/span> module<\/span> java.base;\nimport<\/span> module<\/span> java.desktop;\n\nimport<\/span> java.util.*; \/\/ \u2190 Ambiguity resolved by type-import-on-demand declaration<\/span>\n\npublic<\/span> class<\/span> Ambiguous<\/span> <\/span>{\n List list;\n}<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\nDie zweite Option ist erst seit Java 24<\/a> verf\u00fcgbar. Wenn du das letzte Beispiel mit Java 23 kompilierst, f\u00fchrt dies ebenfalls zur Fehlermeldung \u201ereference to List is ambiguous\u201c<\/em>.<\/p>\n\n\n\n