Importer le package. * Vs importer le package.SpecificType
Est-ce que cela supposerait une différence concernant la surcharge d'écrire une importation chargeant tous les types dans un même package (import Java.*); qu'un simple type spécifique (c'est-à-dire import Java.lang.ClassLoader)? Le second serait-il un moyen plus judicieux d'utiliser que l'autre?
Il n'y a pas de coût de performance ou de frais généraux pour effectuer l'importation. * Par rapport à l'importation de types spécifiques. Cependant, je considère que c'est une meilleure pratique de ne jamais utiliser l'importation. * Ma principale raison est que j'aime garder les choses droites, propres et avec le moins d'ambiguïté possible, et je pense qu'avec une importation. * Vous perdez cela .
Jetez un œil à l'API Java, et vous verrez de nombreuses classes et interfaces avec le même nom dans différents packages.
Par exemple:
Java.lang.reflect.Array
Java.sql.Array
Donc, si vous importez Java.lang.reflect.* et Java.sql.* vous aurez une collision sur le type Array, et devrez les qualifier entièrement dans votre code.
L'importation de classes spécifiques à la place vous évitera ces tracas.
C'est en fait un très mauvais problème.
Supposons que vous écriviez
import a.*;
import b.*;
...
Foo f;
et la classe Foo existe dans le package a.
Maintenant vous archivez votre code parfaitement compilé, et six mois plus tard, quelqu'un ajoute la classe Foo au package b. (C'est peut-être une bibliothèque tierce qui a ajouté des classes dans la dernière version).
Pouf! Maintenant, votre code refuse de compiler.
Jamais utilise l'importation à la demande. C'est mal!
Voir http://javadude.com/articles/importondemandisevil.html pour plus de détails.
Performances RE:
import a.*;
contre
import a.X;
Ne fait aucune différence lors de l'exécution. Le compilateur connecte les noms de classe résolus dans les fichiers .class générés.
Vue minoritaire: dans mon code, j'ai tendance à utiliser des tonnes de classes de quelques paquets avec quelques classes bizarres ici et là. J'aime garder ma liste d'importations petite pour que je puisse voir ce qui se passe en un coup d'œil. Pour ce faire, j'ai fixé le seuil à 4 classes. Au-dessus de cela, Eclipse utilisera * pour mon code. Je trouve que cela maintient mes importations de paquets lisibles, et j'ai tendance à les appeler première chose que je fais quand je regarde une classe, pour répondre à la question: à qui parle-t-il?
Concernant la collision de noms: Quelles sont les chances que vous importiez quatre classes ou plus à partir de deux packages ayant des noms de classe concurrents? SI c'est plus de 10% du temps, vous voudrez peut-être considérer le nombre de packages sur lesquels votre classe s'appuie (par exemple, le refactoriser en classes plus petites).
Une bonne raison de ne jamais utiliser l'importation xxx. * Est d'avoir une vision claire de dépendances .
Vous pouvez savoir plus rapidement que vous utilisez une classe spécifique d'un autre package car elle est répertoriée au début du fichier source.
Après avoir cherché plus d'informations, je suis tombé sur ce site où il est très bien expliqué. Problème d'importation et L'utilisation de * dans une instruction d'importation affecte-t-elle les performances? .
Y a-t-il un problème d'efficacité entre ces deux styles? Peut-être, mais comme les déclarations d'importation n'importent rien dans votre programme, toute différence est très faible. N'oubliez pas qu'il existe une importation implicite Java.lang. * En haut de vos unités de compilation, et Java.lang dans JDK 1.2.2 contient 75 classes et interfaces. Une expérience utilisant un exemple artificiel, avec des milliers d'utilisations de noms de classe qui doivent être recherchées, a montré un changement négligeable dans la vitesse de compilation. Les performances de compilation ne devraient donc probablement pas être considérées comme un facteur lors du choix d'un format plutôt que d'un autre.
Il y a un dernier angle d'intérêt sur les déclarations d'importation. Supposons que vous utilisez une classe interne:
package P;
public class A {
public static class B {}
}
Si vous souhaitez accéder à A à partir d'une autre unité de compilation, vous dites:
import P.*;
ou: importer P.A; Mais si vous souhaitez accéder à B sans qualification, vous devez dire:
import P.A.*;
ou: importer P.A.B; Le premier met à disposition des types dans la classe A du package P. Le second met à disposition uniquement le type B trouvé dans la classe A du package P.
Si vous importez plus de 20 classes à partir du même package, il vaut mieux utiliser import xxx. *. "Clean Code" est également en faveur de l'importation de l'ensemble du package.
J'ai tendance à utiliser la valeur par défaut IDE. Je trouve que cela ne vaut pas vraiment la peine d'être inquiété car il n'a aucun impact sur les performances, et la vérification des dépendances peut être gérée avec une variété d'outils.
Les importations n'ont pas d'importance au niveau du bytecode, il ne devrait donc pas y avoir de différence d'exécution.
Je trouve qu'il est préférable de: a) Être explicite en listant toutes les importations b) Laissez votre IDE le gérer. N'importe lequel des principaux IDE peut automatiquement mettre à jour, trier et terminer vos importations.
J'ai trouvé a) utile à quelques reprises lors du reconditionnement manuel en dehors du contexte d'une refactorisation in-IDE. Comme par exemple, lorsque le marketing change le nom de votre produit et décide que tous vos packages doivent changer de nom.
C'est plus une bonne pratique de codage que quiconque lit votre code saura immédiatement quelles classes sont utilisées par une classe particulière en regardant simplement le bloc d'importation en haut du fichier alors qu'il faudrait creuser pour savoir si vous avez utilisé des caractères génériques.