Une raison de nettoyer les importations inutilisées en Java, autre que de réduire l'encombrement?
Existe-t-il une bonne raison d'éviter les instructions d'importation inutilisées en Java? Si je comprends bien, ils sont là pour le compilateur, donc beaucoup d'importations inutilisées n'auront aucun impact sur le code compilé. Est-ce juste pour réduire l'encombrement et éviter de nommer des conflits à l'avenir?
(Je pose la question car Eclipse avertit des importations inutilisées, ce qui est un peu gênant lorsque je développe du code car je ne souhaite pas supprimer les importations tant que je ne suis pas sûr d'avoir terminé la conception de la classe.)
Je ne pense pas que des problèmes de performances ou quelque chose du genre soient probables si vous ne supprimez pas les importations.
Mais il peut y avoir des conflits de noms, dans de rares cas, par exemple lors de l'importation de l'interface de liste.
Dans Eclipse, vous pouvez toujours utiliser un raccourci (selon le système d'exploitation utilisé: Win: Ctrl + SHIFT + O et Mac: COMMAND + SHIFT + O) pour organiser les importations. Eclipse nettoie ensuite la section d'importation, supprime toutes les importations obsolètes, etc. Si vous avez à nouveau besoin d'importer une chose importée, Eclipse les ajoutera automatiquement pendant que vous complétez l'instruction avec Ctrl + SPACE. Il est donc inutile de conserver le code inutilisé dans votre classe.
Comme toujours, le code inutilisé vous distrait, vous et d’autres personnes, tout en lisant le code et en laissant quelque chose dans votre code actif, car j’en aurais peut-être besoin plus tard, cela est généralement considéré comme une mauvaise pratique.
En premier lieu, si vous supprimez la classe référencée par l'importation du chemin de classe, vous n'obtiendrez pas une erreur stupide du compilateur qui ne sert à rien. Et vous n'obtiendrez pas de faux positifs lorsque vous effectuez une recherche "où utilisé".
Une autre (mais cela serait de nature très spécifique) serait si l’importation non utilisée avait des conflits de noms avec une autre importation, ce qui vous obligerait à utiliser des noms entièrement qualifiés sans nécessité.
Addendum: Aujourd'hui, le serveur de construction a commencé à échouer lors de la compilation (pas même l'exécution du test) avec une erreur liée à l'insuffisance de mémoire. Cela a fonctionné pour toujours et les check-ins n'ont apporté aucune modification au processus de construction, ni d'ajouts significatifs pouvant expliquer cela. Après avoir tenté d'augmenter les paramètres de mémoire (c'est-à-dire exécuter une machine virtuelle Java 64 bits sur un CentOS 64 bits!) Pour atteindre un niveau bien supérieur à celui où les clients pouvaient compiler, j'ai examiné les check-in un par un.
Il y avait une importation incorrecte qu'un développeur avait utilisée et abandonnée (ils ont utilisé la classe, l'ont importée automatiquement, puis ont réalisé que c'était une erreur). Cette importation inutilisée est entrée dans un niveau distinct de l'application qui, bien que IDE] ne soit pas configuré pour les séparer, constitue le processus de construction. Cette importation unique entraînée dans tant de classes que le compilateur a tenté de compiler sans disposer des bibliothèques dépendantes pertinentes dans le chemin d'accès aux classes a provoqué tant de problèmes que l'erreur de mémoire insuffisante s'est produite. Il a fallu une heure pour résoudre ce problème causé par une importation non utilisée.
D'un point de vue puriste, toute dépendance est une "contrainte" sur le produit et peut donc poser des problèmes de maintenance ultérieurement.
Par exemple, supposons que votre programme utilise la classe com.X.Y.Z.ObjectPool et que, plus tard, vous décidiez de ne pas l'utiliser, mais ne supprimez jamais l'importation. Si quelqu'un d'autre veut maintenant instancier org.W.V.Y.ObjectPool et se référer à ObjectPool, il ne reçoit aucun avertissement à ce sujet tant qu'il ne se pose pas un problème de distribution ou d'appel.
Ce n'est d'ailleurs pas un scénario irréaliste. Chaque fois que vous demandez à Eclipse de vous demander quelle version spécifique de X vous souhaitez importer et que vous en choisissez un parmi de nombreux packages, il existe un scénario dans lequel si vous aviez importé le produit, vous auriez peut-être fait le mauvais choix sans le savoir.
De toute façon, vous pouvez demander à Eclipse de les nettoyer pour vous.
Pour votre information, cela m’a surpris, car je ne pensais pas que l’organisation des importations éliminait les importations inutilisées, je pensais que cela venait de les trier.
Supprimer automatiquement les importations au cours d'une opération de sauvegarde m'a causé quelques problèmes lorsque, par exemple, lors du développement ou des tests, vous rencontrez un problème et commentez du code. Lorsque vous l'enregistrez, les importations utilisées par la section de code commentée sont supprimées. Parfois, ce n'est pas un problème car vous pouvez annuler (Ctrl+Z) les modifications, mais d’autres fois, ce n’est pas aussi simple que d’autres modifications. J'ai également eu un problème: lorsque j'ai supprimé le code (j'ai déjà commenté puis sauvegardé, supprimant ainsi les importations de ce code), il a automatiquement essayé de deviner les importations nécessaires et de récupérer les mauvaises (par exemple, je pense avait utilisé une classe StringUtils et en avait choisi une autre portant le même nom dans la mauvaise bibliothèque).
Je préfère organiser manuellement les importations plutôt que de l’avoir comme action de sauvegarde.
Attention? Demandez à Eclipse de les nettoyer automatiquement pour vous. C'est ce que fait IntelliJ. Si c'est assez intelligent pour vous avertir, il devrait être assez intelligent pour les nettoyer. Je recommanderais de rechercher un paramètre Eclipse pour lui dire de cesser d'être un tel bourru et de faire quelque chose.
Cela concerne la clarté du programme, utile pour la maintenance.
Si vous deviez maintenir un programme, vous découvrirez à quel point il est utile de pouvoir importer une seule classe par ligne.
Pensez au scénario suivant:
import company.billing.*;
import company.humanrerources.*;
// other imports
class SomeClass {
// hundreds or thousands of lines here...
public void veryImportantMethod() {
Customer customer;
Employee comployee;
Department dept.
// do something with them
}
}
Lorsque vous corrigez des bugs ou maintenez un morceau de code (ou que vous le lisez seulement), il est très utile pour le lecteur de savoir à quel paquet appartiennent les classes utilisées. L'utilisation de l'importation de caractères génériques comme indiqué ci-dessus n'aide pas à cette fin.
Même avec un environnement de développement intégré (IDE), vous ne voulez pas survoler ou sauter entre déclaration et retour, il est plus facile de comprendre, en termes de fonctionnalités, les autres packages et classes dont dépend le code actuel.
Si c'est pour un projet personnel ou quelque chose de petit, cela n'a pas vraiment d'importance, mais pour quelque chose de plus grand qui doit être utilisé par d'autres développeurs (et maintenu au fil des ans), c'est un MUST HAVE.
Il n'y a absolument aucune différence de performance avec aucun.
Vous pouvez commenter les déclarations d'importation inutilisées et les avertissements ne vous dérangeront pas, mais vous pouvez voir ce que vous aviez.
Pour Eclipse, j'utilise ceci: fenêtre -> préférences -> Java -> éditeur -> action de sauvegarde -> cochez la case pour organiser les importations (il y a beaucoup d'autres choses utiles ici, comme le formatage, les champs finaux, etc.). .) Ainsi, lorsque je sauvegarde mon fichier, Eclipse supprime les importations unessacry pour moi. À mon avis, si vous n'avez pas besoin de quelque chose, supprimez-le (ou laissez-le être supprimé par Eclipse).
Il n'y a aucun impact sur les performances, mais pour des raisons de lisibilité, vous pouvez le rendre propre. La suppression des importations non utilisées est relativement simple dans Eclipse et dans IntelliJ IDEA.
Eclipse
Windows/Linux -Ctrl+Shift+O
Mac -Cmd+Shift+O
IntelliJ IDEA ou Android Studio
Windows/Linux -Ctrl+Alt+O
Mac -Cmd+Alt+O
Pour moi, une importation de classe inutilisée dans une classe de contrôleur a créé un problème de compilation dans la construction de Jenkins après avoir supprimé la classe importée lors du nettoyage du code et commis la suppression dans git sans tester une version locale.
J'ai lu quelque part, il y a quelques années, que chaque classe importée serait chargée au moment de l'exécution avec la classe importatrice. Donc, supprimer les paquets inutilisés, en particulier les paquets entiers, réduirait le temps système mémoire Bien que je suppose que les versions modernes de Java traitent de cela, alors ce n’est probablement plus une raison.
Et au fait, avec Eclipse, vous pouvez utiliser Ctrl+Shift+O pour organiser les importations, mais vous pouvez également configurer un "nettoyeur" traitant de telles choses (et bien d’autres) chaque fois que vous enregistrez un fichier Java.