{"id":4710,"date":"2025-05-05T13:49:52","date_gmt":"2025-05-05T11:49:52","guid":{"rendered":"https:\/\/www.tutego.de\/blog\/javainsel\/?p=4710"},"modified":"2025-05-05T14:06:34","modified_gmt":"2025-05-05T12:06:34","slug":"insel-update-fuer-java-25-modul-import","status":"publish","type":"post","link":"https:\/\/www.tutego.de\/blog\/javainsel\/2025\/05\/insel-update-fuer-java-25-modul-import\/","title":{"rendered":"Insel-Update f\u00fcr Java 25: Modul-Import"},"content":{"rendered":"

In gr\u00f6\u00dferen Java-Programmen sammeln sich naturgem\u00e4\u00df zahlreiche Import-Deklarationen an. Zwar lassen sich diese in modernen Entwicklungsumgebungen bequem einklappen, doch sie bleiben Teil des Quellcodes und k\u00f6nnen schnell un\u00fcbersichtlich werden.<\/p>\n

Java bietet einige M\u00f6glichkeiten, die Imports zu vereinfachen. Eine Option ist der Einsatz von Wildcards \u2013 etwa <\/span>import java.awt.*<\/span><\/span><\/span>, um s\u00e4mtliche Typen eines Pakets auf einmal zu importieren. Au\u00dferdem wird das Paket <\/span>java.lang<\/span><\/span><\/span> automatisch importiert, sodass dort Typen wie <\/span>String<\/span><\/span><\/span>, <\/span>Math<\/span><\/span><\/span> oder <\/span>Compa<\/span><\/span><\/span>rable<\/span><\/span><\/span> ganz ohne explizite Import-Deklaration verwendet werden k\u00f6nnen.<\/span><\/p>\n

<\/a>In Java 25 wurden Modul-Importe<\/span><\/span>\u00a0<\/span>eingef\u00fchrt, die alle \u00f6ffentlichen Typen der exportierten Pakete eines Moduls sowie die Typen der indirekt referenzierten Module einbinden.<\/span><\/span><\/p>\n

Erkl\u00e4rung<\/span><\/span><\/p>\n

Ein Paket ist eine Sammlung thematisch zusammengeh\u00f6riger Typen \u2013 wie Klassen und Schnittstellen \u2013, die gemeinsam eine bestimmte Funktionalit\u00e4t bereitstellen. Ein Modul ist eine \u00fcbergeordnete Einheit, die mehrere Pakete logisch zusammenfasst. <\/a>Module dienen der besseren Strukturierung gr\u00f6\u00dferer Anwendungen und erm\u00f6glichen es, explizit festzulegen, welche Teile eines Moduls f\u00fcr andere Module zug\u00e4nglich sind und von welchen Modulen es selbst abh\u00e4ngt. Die Java-Standardbibliothek ist vollst\u00e4ndig modularisiert. Eigene Module spielen in der Praxis eine untergeordnete Rolle.<\/span><\/span><\/p>\n

Die Syntax eines Modul-Imports lautet wie folgt:<\/span><\/p>\n

import module Modulname;<\/span><\/pre>\n
Ein typisches Beispiel ist der Import des Basismoduls der Java-Standardbibliothek:<\/span><\/p>\n
import module java.base;<\/span><\/pre>\n
Das Modul <\/span>java.base<\/span><\/span><\/span> ist das zentrale Kernmodul und umfasst essenzielle Pakete wie java.io, <\/span>java.net<\/span><\/span><\/span>, <\/span>java.util<\/span><\/span><\/span> und weitere. Die Javadoc zeigt alle Module und ihre enthaltenen Pakete auf.<\/span><\/p>\n
Namenskonflikte durch Mehrfachimporte<\/span><\/h4>\n
Beim Einsatz von Wildcards in mehreren Paketimporten kann es zu Namenskonflikten kommen, wenn gleichnamige Typen in unterschiedlichen Paketen vorhanden sind. Dasselbe Problem kann auch bei Modul-Importen auftreten, da ein Modul in der Regel viele Pakete mit potenziell gleichnamigen Typen enth\u00e4lt. Ein klassisches Beispiel sind die Typen <\/span>Date<\/span><\/span><\/span> und <\/span>List<\/span><\/span><\/span>, die in mehreren Paketen existieren: Es gibt Date in <\/span>java.util<\/span><\/span><\/span> (Modul <\/span>java.base<\/span><\/span><\/span>) und in <\/span>java.sql<\/span><\/span><\/span> (Modul <\/span>java.sql<\/span><\/span><\/span>) und <\/span>List<\/span><\/span><\/span> in <\/span>java.util<\/span><\/span><\/span> (Modul <\/span>java.base<\/span><\/span><\/span>) und in <\/span>java.awt<\/span><\/span><\/span> (Modul <\/span>java.desktop<\/span><\/span><\/span>).<\/span><\/p>\n
Nehmen wir folgenden Modul-Import an:<\/span><\/p>\n
import module java.base;\u00a0\u00a0\u00a0 <\/span>\/\/ Enth\u00e4lt java.util.Date und java.util.List<\/span>\r\n\r\nimport module java.sql;\u00a0\u00a0\u00a0\u00a0 <\/span>\/\/ Enth\u00e4lt java.sql.Date<\/span>\r\n\r\nimport module java.desktop; \/\/ Enth\u00e4lt java.awt.List<\/span><\/pre>\n
Dann meldet der Compiler einen Fehler, wenn <\/span>Date<\/span><\/span><\/span> oder <\/span>List<\/span><\/span><\/span> im Programm verwendet werden, da <\/span>Date<\/span><\/span><\/span> entweder <\/span>java.util.Date<\/span><\/span><\/span> oder <\/span>java.sql.Date<\/span><\/span><\/span> bedeuten k\u00f6nnte und <\/span>List<\/span><\/span><\/span> entweder <\/span>java.util.List<\/span><\/span><\/span> oder <\/span>java.awt.List<\/span><\/span><\/span>. Der Konflikt tritt also auf, weil die Modul-Importe mehrere Pakete einbinden, die Typen mit denselben einfachen Namen exportieren.<\/span><\/p>\n
Es gibt unterschiedliche L\u00f6sungsans\u00e4tze f\u00fcr das Problem.<\/span><\/p>\n
L\u00f6sung 1<\/span><\/strong>: Eine gezielte Import-Deklaration f\u00fcr den gew\u00fcnschten Typ verwenden:<\/span><\/p>\n
import module java.base;<\/span>\r\n\r\nimport module java.sql;<\/span>\r\n\r\nimport module java.desktop;<\/span>\r\n\r\nimport java.sql.Date<\/span><\/b>;\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>\/\/ Eindeutig \u2013 nutzt Date aus java.sql und<\/span>\r\n\r\nimport java.util.List<\/span><\/b>;\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>\/\/ List aus dem Paket java.util<\/span><\/pre>\n
L\u00f6sung 2<\/span><\/strong>: Ein Wildcard-Import f\u00fcr die Priorisierung eines Pakets:<\/span><\/p>\n
import module java.base;<\/span>\r\n\r\nimport module java.sql;<\/span>\r\n\r\nimport module java.desktop;<\/span>\r\n\r\nimport java.util.*<\/span><\/b>;\u00a0 <\/span>\/\/ Priorisiert Typen aus java.util gegen\u00fcber Modul-Importen<\/span>\r\n\r\nimport java.sql.*<\/span><\/b>;\u00a0\u00a0 <\/span>\/\/ Priorisiert Typen aus java.sql gegen\u00fcber Modul-Importen<\/span><\/pre>\n
Die Mehrdeutigkeit f\u00fcr <\/span>Date<\/span><\/span><\/span> bleibt bestehen, da die Wildcard-Importe <\/span>import java.util.*<\/span><\/span><\/span> und <\/span>import java.sql.*<\/span><\/span><\/span> gleichrangig sind. Um <\/span>Date<\/span><\/span><\/span> eindeutig zu machen, ist ein gezielter Klassen-Import wie <\/span>import java.sql.Date<\/span><\/span><\/span> erforderlich. Der Typ <\/span>List<\/span><\/span><\/span> wird durch <\/span>import java.util.*<\/span><\/span><\/span> auf <\/span>java.util.L<\/span><\/span><\/span>ist<\/span><\/span><\/span> festgelegt, da dieser Wildcard-Import den Modul-Import <\/span>java.desktop<\/span><\/span><\/span> \u00fcberlagert.<\/span><\/p>\n
L\u00f6sung 3<\/span><\/strong>: Vollst\u00e4ndige Qualifikation von Typen:<\/span><\/p>\n
import module java.base;<\/span>\r\n\r\nimport module java.sql;<\/span>\r\n\r\nimport module java.desktop;<\/span><\/pre>\n
Und dann zum Beispiel:<\/span><\/p>\n
java.sql<\/span><\/strong>.Date sqlDate = new java.sql<\/strong>.Date(System.currentTimeMillis());<\/span><\/pre>\n
Um es zusammenzufassen: Die Regel der Spezifit\u00e4t hilft bei der Aufl\u00f6sung solcher Namenskonflikte:<\/span><\/p>\n
\u00b7\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span>Einzelne Typ-Importe (<\/span>import java.sql.Date<\/span><\/span><\/span>) haben Vorrang vor<\/span><\/p>\n
\u00b7\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span>Paket-Importen mit Wildcard (<\/span>import java.util.*<\/span><\/span><\/span>), die wiederum Vorrang haben vor<\/span><\/p>\n
\u00b7\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span>Modul-Importen (<\/span>import module java.base<\/span><\/span><\/span>).<\/span><\/p>\n
Strukturierung<\/span><\/h4>\n
Zur besseren Lesbarkeit des Codes empfiehlt es sich, Import-Deklarationen logisch zu gruppieren, in folgender Reihenfolge:<\/span><\/p>\n
\/\/ Modul-Importe<\/span>\r\n\r\nimport module java.base;<\/span>\r\n\r\nimport module java.sql;<\/span>\r\n\r\n\u00a0<\/span>\r\n\r\n\/\/ Paket-Importe<\/span>\r\n\r\nimport java.util.*;<\/span>\r\n\r\nimport javax.sql.*;<\/span>\r\n\r\n\u00a0<\/span>\r\n\r\n\/\/ Einzelne Typ-Importe<\/span>\r\n\r\nimport java.sql.Date;<\/span>\r\n\r\n\u00a0<\/span>\r\n\r\nclass Application { }<\/span><\/pre>\n","protected":false},"excerpt":{"rendered":"
In gr\u00f6\u00dferen Java-Programmen sammeln sich naturgem\u00e4\u00df zahlreiche Import-Deklarationen an. Zwar lassen sich diese in modernen Entwicklungsumgebungen bequem einklappen, doch sie bleiben Teil des Quellcodes und k\u00f6nnen schnell un\u00fcbersichtlich werden. Java bietet einige M\u00f6glichkeiten, die Imports zu vereinfachen. Eine Option ist der Einsatz von Wildcards \u2013 etwa import java.awt.*, um s\u00e4mtliche Typen eines Pakets auf einmal […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_jetpack_memberships_contains_paid_content":false,"footnotes":"","_links_to":"","_links_to_target":""},"categories":[1,11,125],"tags":[],"class_list":["post-4710","post","type-post","status-publish","format-standard","hentry","category-allgemein","category-insel","category-java-25"],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/posts\/4710","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/comments?post=4710"}],"version-history":[{"count":3,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/posts\/4710\/revisions"}],"predecessor-version":[{"id":4713,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/posts\/4710\/revisions\/4713"}],"wp:attachment":[{"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/media?parent=4710"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/categories?post=4710"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/tags?post=4710"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}