Pourquoi l'utilisation d'un caractère générique avec une déclaration d'importation Java est-elle mauvaise?

Il est beaucoup plus pratique et plus propre d'utiliser une seule déclaration comme

import java.awt.*;

que d'importer un tas de classes individuelles

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

Quel est le problème avec l'utilisation d'un caractère générique dans la importdéclaration?

Le seul problème est qu'il encombre votre espace de noms local. Par exemple, disons que vous écrivez une application Swing, et donc que vous en avez besoin java.awt.Event, et que vous vous connectez également au système de calendrier de l'entreprise, qui l'a com.mycompany.calendar.Event. Si vous importez les deux à l'aide de la méthode générique, l'une des trois choses suivantes se produit:

1. Vous avez un conflit de dénomination entre java.awt.Eventet com.mycompany.calendar.Eventet vous ne pouvez donc même pas compiler.
2. En fait, vous ne parvenez à en importer qu'une seule (une seule de vos deux importations le fait .*), mais ce n'est pas la bonne, et vous avez du mal à comprendre pourquoi votre code prétend que le type est incorrect.
3. Lorsque vous compilez votre code, il n'y en a pas com.mycompany.calendar.Event, mais lorsqu'ils en ajoutent plus tard, votre code précédemment valide cesse soudainement de compiler.

L'avantage de répertorier explicitement toutes les importations est que je peux dire en un coup d'œil quelle classe vous vouliez utiliser, ce qui facilite simplement la lecture du code. Si vous faites juste une chose ponctuelle rapide, il n'y a rien de mal explicitement , mais les futurs responsables vous remercieront pour votre clarté sinon.

Voici un vote pour les importations d'étoiles. Une instruction import est destinée à importer un package , pas une classe. Il est beaucoup plus propre d'importer des packages entiers; les problèmes identifiés ici (par exemple java.sql.Datevs java.util.Date) sont facilement résolus par d'autres moyens, pas vraiment traités par des importations spécifiques et ne justifient certainement pas les importations incroyablement pédantes sur toutes les classes. Il n'y a rien de plus déconcertant que d'ouvrir un fichier source et d'avoir à parcourir 100 instructions d'importation.

Faire des importations spécifiques rend la refactorisation plus difficile; si vous supprimez / renommez une classe, vous devez supprimer toutes ses importations spécifiques. Si vous basculez une implémentation vers une classe différente dans le même package, vous devez aller corriger les importations. Bien que ces étapes supplémentaires puissent être automatisées, ce sont vraiment des gains de productivité sans gain réel.

Même si Eclipse ne faisait pas d'importations de classe par défaut, tout le monde ferait toujours des importations d'étoiles. Je suis désolé, mais il n'y a vraiment aucune justification rationnelle pour effectuer des importations spécifiques.

Voici comment gérer les conflits de classe:

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

s'il vous plaît voir mon article Import on Demand is Evil

En bref, le plus gros problème est que votre code peut se casser lorsqu'une classe est ajoutée à un package que vous importez. Par exemple:

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

// ...

List list;

En Java 1.1, c'était bien; La liste a été trouvée dans java.awt et il n'y a pas eu de conflit.

Supposons maintenant que vous archiviez votre code parfaitement fonctionnel et qu'un an plus tard, quelqu'un d'autre le fasse sortir pour l'éditer et utilise Java 1.2.

Java 1.2 a ajouté une interface nommée List à java.util. BOOM! Conflit. Le code fonctionnant parfaitement ne fonctionne plus.

Il s'agit d'une fonction de langage EVIL . Il n'y a AUCUNE raison pour que le code arrête de compiler juste parce qu'un type est ajouté à un package ...

De plus, il est difficile pour un lecteur de déterminer quel "Foo" vous utilisez.

Il n'est pas mauvais d'utiliser un caractère générique avec une instruction d'importation Java.

Dans Clean Code , Robert C. Martin recommande en fait de les utiliser pour éviter les longues listes d'importation.

Voici la recommandation:

J1: éviter les longues listes d'importation en utilisant des caractères génériques

Si vous utilisez deux classes ou plus à partir d'un package, importez le package complet avec

package d'importation. *;

Les longues listes d'importations sont intimidantes pour le lecteur. Nous ne voulons pas encombrer les sommets de nos modules avec 80 lignes d'importations. Nous voulons plutôt que les importations soient une déclaration concise sur les packages avec lesquels nous collaborons.

Les importations spécifiques sont des dépendances matérielles, contrairement aux importations génériques. Si vous importez spécifiquement une classe, cette classe doit exister. Mais si vous importez un package avec un caractère générique, aucune classe particulière n'a besoin d'exister. L'instruction import ajoute simplement le package au chemin de recherche lors de la recherche de noms. Donc, aucune véritable dépendance n'est créée par de telles importations, et elles servent donc à garder nos modules moins couplés.

Il y a des moments où la longue liste d'importations spécifiques peut être utile. Par exemple, si vous traitez du code hérité et que vous voulez savoir pour quelles classes vous avez besoin de construire des mocks et des stubs, vous pouvez parcourir la liste des importations spécifiques pour trouver les vrais noms qualifiés de toutes ces classes, puis mettre les talons appropriés en place. Cependant, cette utilisation pour des importations spécifiques est très rare. De plus, la plupart des IDE modernes vous permettront de convertir les importations génériques en une liste d'importations spécifiques avec une seule commande. Ainsi, même dans le cas hérité, il est préférable d'importer des caractères génériques.

Les importations de caractères génériques peuvent parfois provoquer des conflits de noms et des ambiguïtés. Deux classes portant le même nom, mais dans des packages différents, devront être spécifiquement importées, ou au moins spécifiquement qualifiées lors de leur utilisation. Cela peut être gênant mais est suffisamment rare pour que l'utilisation d'importations génériques soit généralement meilleure que les importations spécifiques.

Performances : aucun impact sur les performances car le code d'octet est identique. même si cela entraînera des frais généraux de compilation.

Compilation : sur ma machine personnelle, Compiler une classe vide sans rien importer prend 100 ms mais la même classe lors de l'importation java. * Prend 170 ms.

Il encombre votre espace de noms, vous obligeant à spécifier complètement tous les noms de classe qui sont ambigus. L'occurrence la plus courante de ceci est avec:

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

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

Cela permet également de concrétiser vos dépendances, car toutes vos dépendances sont répertoriées en haut du fichier.

1. Il aide à identifier les conflits de nom de classe: deux classes dans des packages différents qui ont le même nom. Cela peut être masqué avec l'importation *.
2. Il rend les dépendances explicites, afin que quiconque doit lire votre code plus tard sache ce que vous vouliez importer et ce que vous ne vouliez pas importer.
3. Cela peut rendre la compilation plus rapide car le compilateur n'a pas à rechercher l'ensemble du package pour identifier les dépendances, bien que ce ne soit généralement pas un problème énorme avec les compilateurs modernes.
4. Les aspects gênants des importations explicites sont minimisés avec les IDE modernes. La plupart des IDE vous permettent de réduire la section d'importation afin qu'elle ne gêne pas, de remplir automatiquement les importations en cas de besoin et d'identifier automatiquement les importations inutilisées pour les nettoyer.

La plupart des endroits où j'ai travaillé qui utilisent une quantité importante de Java font des importations explicites une partie de la norme de codage. Parfois, j'utilise toujours * pour le prototypage rapide, puis j'élargis les listes d'importation (certains IDE le feront également pour vous) lors de la production du code.

Je préfère les importations spécifiques, car cela me permet de voir toutes les références externes utilisées dans le fichier sans regarder l'ensemble du fichier. (Oui, je sais que cela ne montrera pas nécessairement des références pleinement qualifiées. Mais je les évite autant que possible.)

Dans un projet précédent, j'ai constaté que le passage de * -importations à des importations spécifiques réduisait le temps de compilation de moitié (d'environ 10 minutes à environ 5 minutes). L'import * * oblige le compilateur à rechercher dans chacun des packages répertoriés une classe correspondant à celle que vous avez utilisée. Bien que ce temps puisse être petit, il s'additionne pour les grands projets.

Un effet secondaire de l'importation * était que les développeurs copiaient et collaient les lignes d'importation courantes plutôt que de penser à ce dont ils avaient besoin.

Dans le livre DDD

Quelle que soit la technologie de développement sur laquelle l'implémentation sera basée, recherchez des moyens de minimiser le travail de refactorisation des MODULES. En Java, il n'y a pas d'échappatoire à l'importation dans des classes individuelles, mais vous pouvez au moins importer des packages entiers à la fois, reflétant ainsi l'intention que les packages soient des unités hautement cohérentes tout en réduisant simultanément l'effort de modification des noms de package.

Et s'il encombre l'espace de noms local, ce n'est pas votre faute - blâmez la taille du paquet.

• Il n'y a aucun impact sur l'exécution, car le compilateur remplace automatiquement * par des noms de classe concrets. Si vous décompilez le fichier .class, vous ne verriez jamais import ...*.

• C # utilise toujours * (implicitement) car vous ne pouvez usingempaqueter que le nom. Vous ne pouvez jamais spécifier le nom de la classe. Java introduit la fonctionnalité après c #. (Java est tellement délicat à bien des égards, mais il dépasse ce sujet).

• Dans Intellij Idea, lorsque vous "organisez les importations", il remplace automatiquement plusieurs importations du même package par *. Il s'agit d'une fonction obligatoire car vous ne pouvez pas la désactiver (bien que vous puissiez augmenter le seuil).

• Le cas répertorié par la réponse acceptée n'est pas valide. Sans * vous avez toujours le même problème. Vous devez spécifier le nom de la pakcage dans votre code, que vous utilisiez * ou non.

Pour mémoire: lorsque vous ajoutez une importation, vous indiquez également vos dépendances.

Vous pouvez voir rapidement quelles sont les dépendances des fichiers (à l'exclusion des classes du même espace de noms).

Le plus important est que l'importation java.awt.*peut rendre votre programme incompatible avec une future version Java:

Supposons que vous ayez une classe nommée "ABC", vous utilisez JDK 8 et vous importez java.util.*. Supposons maintenant que Java 9 sorte et qu'il ait une nouvelle classe dans le package java.utilqui, par coïncidence, se nomme également "ABC". Votre programme ne compilera plus sur Java 9, car le compilateur ne sait pas si avec le nom "ABC" vous voulez dire votre propre classe ou la nouvelle classe java.awt.

Vous n'aurez pas ce problème lorsque vous importerez uniquement les classes explicitement à partir de celles java.awtque vous utilisez réellement.

Ressources:

Importations Java

Parmi tous les points valables formulés des deux côtés, je n'ai pas trouvé ma principale raison d'éviter le caractère générique: j'aime pouvoir lire le code et savoir directement ce qu'est chaque classe, ou si sa définition n'est pas dans la langue ou le fichier, où le trouver. Si plusieurs packages sont importés avec *, je dois rechercher chacun d'eux pour trouver une classe que je ne reconnais pas. La lisibilité est suprême et j'accepte que le code ne nécessite pas d' IDE pour le lire.