Warum ist die Verwendung eines Platzhalters mit einer Java-Importanweisung schlecht?

Es ist viel bequemer und sauberer, eine einzelne Aussage wie zu verwenden

import java.awt.*;

als eine Reihe von einzelnen Klassen zu importieren

import java.awt.Panel;
import java.awt.Graphics;
import java.awt.Canvas;
...

Was ist falsch an der Verwendung eines Platzhalters in der importAnweisung?

Das einzige Problem dabei ist, dass es Ihren lokalen Namespace überfüllt. Nehmen wir zum Beispiel an, Sie schreiben eine Swing-App und benötigen diese java.awt.Eventund sind auch mit dem Kalendersystem des Unternehmens verbunden, das über eine solche verfügt com.mycompany.calendar.Event. Wenn Sie beide mithilfe der Platzhaltermethode importieren, geschieht Folgendes:

1. Sie haben einen direkten Namenskonflikt zwischen java.awt.Eventund com.mycompany.calendar.Eventund können daher nicht einmal kompilieren.
2. Sie können tatsächlich nur einen importieren (nur einer Ihrer beiden Importe .*), aber es ist der falsche, und Sie haben Schwierigkeiten herauszufinden, warum Ihr Code behauptet, der Typ sei falsch.
3. Wenn Sie Ihren Code kompilieren, gibt es keine com.mycompany.calendar.Event, aber wenn sie später einen hinzufügen, wird Ihr zuvor gültiger Code plötzlich nicht mehr kompiliert.

Der Vorteil der expliziten Auflistung aller Importe besteht darin, dass ich auf einen Blick erkennen kann, welche Klasse Sie verwenden wollten, was das Lesen des Codes erheblich erleichtert. Wenn Sie nur eine kurze einmalige Sache machen, ist nichts explizit falsch , aber zukünftige Betreuer werden Ihnen für Ihre Klarheit danken.

Hier ist eine Abstimmung für Sternimporte. Eine import-Anweisung soll ein Paket importieren , keine Klasse. Es ist viel sauberer, ganze Pakete zu importieren. Die hier identifizierten Probleme (z. B. java.sql.Datevs java.util.Date) können leicht auf andere Weise behoben werden, werden durch bestimmte Importe nicht wirklich angegangen und rechtfertigen sicherlich nicht wahnsinnig pedantische Importe für alle Klassen. Es gibt nichts Beunruhigenderes, als eine Quelldatei zu öffnen und 100 Importanweisungen durchzublättern.

Durch bestimmte Importe wird das Refactoring schwieriger. Wenn Sie eine Klasse entfernen / umbenennen, müssen Sie alle spezifischen Importe entfernen . Wenn Sie eine Implementierung in eine andere Klasse im selben Paket wechseln, müssen Sie die Importe korrigieren. Während diese zusätzlichen Schritte automatisiert werden können, sind sie wirklich Produktivitätseinbußen ohne wirklichen Gewinn.

Selbst wenn Eclipse standardmäßig keine Klassenimporte durchführen würde, würden alle immer noch Sternimporte durchführen. Es tut mir leid, aber es gibt wirklich keine vernünftige Rechtfertigung für bestimmte Importe.

So gehen Sie mit Klassenkonflikten um:

import java.sql.*;
import java.util.*;
import java.sql.Date;

Bitte lesen Sie meinen Artikel Import on Demand ist böse

Kurz gesagt, das größte Problem ist, dass Ihr Code beschädigt werden kann, wenn eine Klasse zu einem von Ihnen importierten Paket hinzugefügt wird . Zum Beispiel:

import java.awt.*;
import java.util.*;

// ...

List list;

In Java 1.1 war dies in Ordnung; Die Liste wurde in java.awt gefunden und es gab keinen Konflikt.

Angenommen, Sie checken Ihren perfekt funktionierenden Code ein und ein Jahr später bringt ihn jemand anderes heraus, um ihn zu bearbeiten, und verwendet Java 1.2.

Java 1.2 hat java.util eine Schnittstelle namens List hinzugefügt. BOOM! Konflikt. Der perfekt funktionierende Code funktioniert nicht mehr.

Dies ist eine böse Sprachfunktion . Es gibt keinen Grund, warum der Code nicht mehr kompiliert werden sollte, nur weil einem Paket ein Typ hinzugefügt wurde ...

Außerdem ist es für einen Leser schwierig zu bestimmen, welches "Foo" Sie verwenden.

Es ist nicht schlecht, einen Platzhalter mit einer Java-Importanweisung zu verwenden.

In Clean Code empfiehlt Robert C. Martin tatsächlich, sie zu verwenden, um lange Importlisten zu vermeiden.

Hier ist die Empfehlung:

J1: Vermeiden Sie lange Importlisten, indem Sie Platzhalter verwenden

Wenn Sie zwei oder mehr Klassen aus einem Paket verwenden, importieren Sie das gesamte Paket mit

Paket importieren. *;

Lange Importlisten entmutigen den Leser. Wir wollen die Spitzen unserer Module nicht mit 80 Importzeilen überladen. Vielmehr möchten wir, dass die Importe eine präzise Aussage darüber sind, mit welchen Paketen wir zusammenarbeiten.

Bestimmte Importe sind harte Abhängigkeiten, Platzhalterimporte hingegen nicht. Wenn Sie speziell eine Klasse importieren, muss diese Klasse vorhanden sein. Wenn Sie jedoch ein Paket mit einem Platzhalter importieren, müssen keine bestimmten Klassen vorhanden sein. Die import-Anweisung fügt das Paket einfach dem Suchpfad hinzu, wenn nach Namen gesucht wird. Durch solche Importe entsteht also keine echte Abhängigkeit, und sie dienen daher dazu, unsere Module weniger gekoppelt zu halten.

Es gibt Zeiten, in denen die lange Liste bestimmter Importe nützlich sein kann. Wenn Sie beispielsweise mit Legacy-Code arbeiten und herausfinden möchten, für welche Klassen Sie Mocks und Stubs erstellen müssen, können Sie die Liste der spezifischen Importe durchgehen, um die tatsächlichen qualifizierten Namen aller dieser Klassen zu ermitteln und dann zu setzen die entsprechenden Stichleitungen vorhanden. Diese Verwendung für bestimmte Importe ist jedoch sehr selten. Darüber hinaus können Sie mit den meisten modernen IDEs die Wildcard-Importe mit einem einzigen Befehl in eine Liste spezifischer Importe konvertieren. Selbst im Legacy-Fall ist es besser, Platzhalter zu importieren.

Platzhalterimporte können manchmal zu Namenskonflikten und Mehrdeutigkeiten führen. Zwei Klassen mit demselben Namen, jedoch in unterschiedlichen Paketen, müssen speziell importiert oder zumindest speziell qualifiziert werden, wenn sie verwendet werden. Dies kann ein Ärgernis sein, ist jedoch selten genug, dass die Verwendung von Platzhalterimporten im Allgemeinen immer noch besser ist als bestimmte Importe.

Performance : Keine Auswirkung auf die Leistung, da der Bytecode gleich ist. Dies führt jedoch zu einigen Kompilierungskosten.

Kompilierung : Auf meinem PC dauert das Kompilieren einer leeren Klasse ohne Importieren 100 ms, beim Importieren von Java jedoch dieselbe Klasse. * 170 ms.

Es überfüllt Ihren Namespace und erfordert, dass Sie alle mehrdeutigen Klassennamen vollständig angeben. Das häufigste Auftreten ist:

import java.util.*;
import java.awt.*;

...
List blah; // Ambiguous, needs to be qualified.

Es hilft auch dabei, Ihre Abhängigkeiten konkret zu machen, da alle Ihre Abhängigkeiten oben in der Datei aufgeführt sind.

1. Es hilft, Klassennamenkonflikte zu identifizieren: zwei Klassen in verschiedenen Paketen mit demselben Namen. Dies kann mit dem * Import maskiert werden.
2. Abhängigkeiten werden explizit angegeben, sodass jeder, der Ihren Code später lesen muss, weiß, was Sie importieren wollten und was Sie nicht importieren wollten.
3. Dies kann die Kompilierung beschleunigen, da der Compiler nicht das gesamte Paket durchsuchen muss, um Abhängigkeiten zu identifizieren, obwohl dies bei modernen Compilern normalerweise keine große Sache ist.
4. Die unbequemen Aspekte expliziter Importe werden mit modernen IDEs minimiert. Mit den meisten IDEs können Sie den Importabschnitt reduzieren, damit er nicht im Weg ist, Importe bei Bedarf automatisch füllen und nicht verwendete Importe automatisch identifizieren, um sie zu bereinigen.

Die meisten Orte, an denen ich gearbeitet habe und die eine signifikante Menge von Java verwenden, machen explizite Importe zu einem Teil des Codierungsstandards. Manchmal verwende ich * immer noch für das schnelle Prototyping und erweitere dann die Importlisten (einige IDEs erledigen dies auch für Sie), wenn ich den Code produziere.

Ich bevorzuge bestimmte Importe, da ich so alle in der Datei verwendeten externen Referenzen anzeigen kann, ohne die gesamte Datei zu betrachten. (Ja, ich weiß, dass nicht unbedingt vollständig qualifizierte Referenzen angezeigt werden. Aber ich vermeide sie, wann immer dies möglich ist.)

In einem früheren Projekt stellte ich fest, dass der Wechsel von * -Importen zu bestimmten Importen die Kompilierungszeit um die Hälfte reduzierte (von ungefähr 10 Minuten auf ungefähr 5 Minuten). Mit dem * -Import durchsucht der Compiler jedes der aufgelisteten Pakete nach einer Klasse, die der von Ihnen verwendeten entspricht. Diese Zeit kann zwar klein sein, summiert sich jedoch für große Projekte.

Ein Nebeneffekt des * -Imports war, dass Entwickler gängige Importzeilen kopieren und einfügen, anstatt darüber nachzudenken, was sie benötigen.

Im DDD-Buch

Suchen Sie in jeder Entwicklungstechnologie, auf der die Implementierung basiert, nach Möglichkeiten, die Arbeit beim Refactoring von MODULES zu minimieren. In Java gibt es keinen Ausweg aus dem Import in einzelne Klassen, aber Sie können mindestens ganze Pakete gleichzeitig importieren, was die Absicht widerspiegelt, dass Pakete sehr zusammenhängende Einheiten sind, während gleichzeitig der Aufwand für das Ändern von Paketnamen verringert wird.

Und wenn es den lokalen Namespace überfüllt, ist es nicht Ihre Schuld - beschuldigen Sie die Größe des Pakets.

• Es gibt keine Auswirkungen auf die Laufzeit, da der Compiler das * automatisch durch konkrete Klassennamen ersetzt. Wenn Sie die .class-Datei dekompilieren, werden Sie nie sehen import ...*.

• C # verwendet immer * (implizit), da Sie nur den usingPaketnamen verwenden können. Sie können den Klassennamen niemals angeben. Java führt die Funktion nach c # ein. (Java ist in vielerlei Hinsicht so schwierig, aber es geht über dieses Thema hinaus).

• Wenn Sie in Intellij Idea "Importe organisieren", werden automatisch mehrere Importe desselben Pakets durch * ersetzt. Dies ist eine obligatorische Funktion, da Sie sie nicht deaktivieren können (obwohl Sie den Schwellenwert erhöhen können).

• Der in der akzeptierten Antwort aufgeführte Fall ist ungültig. Ohne * hast du immer noch das gleiche Problem. Sie müssen den Paketnamen in Ihrem Code angeben, unabhängig davon, ob Sie * verwenden oder nicht.

Für den Datensatz: Wenn Sie einen Import hinzufügen, geben Sie auch Ihre Abhängigkeiten an.

Sie können schnell erkennen, welche Abhängigkeiten Dateien haben (ausgenommen Klassen mit demselben Namespace).

Das Wichtigste ist, dass der Import java.awt.*Ihr Programm mit einer zukünftigen Java-Version inkompatibel machen kann:

Angenommen, Sie haben eine Klasse mit dem Namen "ABC", verwenden JDK 8 und importieren java.util.*. Nehmen wir nun an, dass Java 9 herauskommt und eine neue Klasse im Paket hat java.util, die zufällig auch "ABC" heißt. Ihr Programm wird jetzt nicht unter Java 9 kompiliert, da der Compiler nicht weiß, ob Sie mit dem Namen "ABC" Ihre eigene Klasse oder die neue Klasse in meinenjava.awt .

Sie werden dieses Problem nicht haben, wenn Sie nur die Klassen explizit importieren java.awt, die Sie tatsächlich verwenden.

Ressourcen:

Java-Importe

Unter all den gültigen Punkten, die auf beiden Seiten gemacht wurden, habe ich meinen Hauptgrund, den Platzhalter zu vermeiden, nicht gefunden: Ich möchte den Code lesen und direkt wissen können, was jede Klasse ist oder ob ihre Definition nicht in der Sprache oder ist die Datei, wo es zu finden ist. Wenn mehr als ein Paket mit * importiert wird, muss ich jedes einzelne durchsuchen, um eine Klasse zu finden, die ich nicht erkenne. Die Lesbarkeit ist oberstes Gebot, und ich stimme zu, dass für den Code des Codes keine IDE erforderlich sein sollte .