Réponses:
Voir documentation
La déclaration d'importation statique est analogue à la déclaration d'importation normale. Lorsque la déclaration d'importation normale importe des classes à partir de packages, ce qui permet leur utilisation sans qualification de package, la déclaration d'importation statique importe des membres statiques à partir de classes, ce qui permet de les utiliser sans qualification de classe.
Alors, quand devez-vous utiliser l'importation statique? Avec parcimonie! Utilisez-le uniquement lorsque vous seriez autrement tenté de déclarer des copies locales des constantes ou d'abuser de l'héritage (le Constant Interface Antipattern). En d'autres termes, utilisez-le lorsque vous avez besoin d'un accès fréquent à des membres statiques d'une ou deux classes. Si vous abusez de la fonction d'importation statique, elle peut rendre votre programme illisible et impossible à maintenir, polluant son espace de noms avec tous les membres statiques que vous importez. Les lecteurs de votre code (y compris vous, quelques mois après l'avoir écrit) ne sauront pas de quelle classe provient un membre statique. L'importation de tous les membres statiques d'une classe peut être particulièrement préjudiciable à la lisibilité; si vous n'avez besoin que d'un ou deux membres, importez-les individuellement. Utilisé de manière appropriée, l'importation statique peut rendre votre programme plus lisible,
Il n'y a aucune différence entre ces deux importations que vous déclarez. Vous pouvez cependant utiliser l'importation statique pour autoriser un accès sans réserve aux membres statiques d'autres classes. Où je devais faire ça:
import org.apache.commons.lang.StringUtils;
.
.
.
if (StringUtils.isBlank(aString)) {
.
.
.
Je peux le faire:
import static org.apache.commons.lang.StringUtils.isBlank;
.
.
.
if (isBlank(aString)) {
.
.
.
Vous pouvez en voir plus dans la documentation .
L'importation statique est utilisée pour importer des champs / méthodes statiques d'une classe au lieu de:
package test;
import org.example.Foo;
class A {
B b = Foo.B_INSTANCE;
}
Tu peux écrire :
package test;
import static org.example.Foo.B_INSTANCE;
class A {
B b = B_INSTANCE;
}
Il est utile si vous utilisez souvent une constante d'une autre classe dans votre code et si l'importation statique n'est pas ambiguë.
Btw, dans votre exemple "import statique org.example.Myclass;" ne fonctionnera pas: l'importation est pour la classe, l'importation statique est pour les membres statiques d'une classe.
L'idée de base de l'importation statique est que chaque fois que vous utilisez une classe statique, une variable statique ou une énumération, vous pouvez les importer et vous épargner de la frappe.
Je vais développer mon point avec exemple.
import java.lang.Math;
class WithoutStaticImports {
public static void main(String [] args) {
System.out.println("round " + Math.round(1032.897));
System.out.println("min " + Math.min(60,102));
}
}
Même code, avec des importations statiques:
import static java.lang.System.out;
import static java.lang.Math.*;
class WithStaticImports {
public static void main(String [] args) {
out.println("round " + round(1032.897));
out.println("min " + min(60,102));
}
}
Remarque : l'importation statique peut rendre votre code confus à lire.
import static java.lang.Math
sans l'astérisque?
la différence entre "import com.showboy.Myclass statique" et "import com.showboy.Myclass"?
Le premier doit générer une erreur de compilation car l'importation statique ne fonctionne que pour l'importation de champs ou de types de membres. (en supposant que MyClass n'est pas une classe interne ou un membre de showboy)
Je pense que tu voulais dire
import static com.showboy.MyClass.*;
ce qui rend tous les champs statiques et les membres de MyClass disponibles dans l'unité de compilation réelle sans avoir à les qualifier ... comme expliqué ci-dessus
Le import
permet au programmeur java d'accéder aux classes d'un package sans qualification de package.
La static import
fonctionnalité permet d'accéder aux membres statiques d'une classe sans qualification de classe.
Le import
fournit l'accessibilité aux classes et à l'interface tandis qu'il static import
fournit l'accessibilité aux membres statiques de la classe.
Exemple :
Avec importation
import java.lang.System.*;
class StaticImportExample{
public static void main(String args[]){
System.out.println("Hello");
System.out.println("Java");
}
}
Avec importation statique
import static java.lang.System.*;
class StaticImportExample{
public static void main(String args[]){
out.println("Hello");//Now no need of System.out
out.println("Java");
}
}
Voir aussi: Qu'est-ce que l'importation statique dans Java 5
Supposons que vous ayez des champs et des méthodes statiques dans une classe appelée à l' MyClass
intérieur d'un package appelé myPackage
et que vous souhaitez y accéder directement en tapant myStaticField
ou myStaticMethod
sans taper à chaque fois MyClass.myStaticField
ouMyClass.myStaticMethod
.
Remarque: vous devez faire un
import myPackage.MyClass
ou myPackage.*
pour accéder aux autres ressources
Le static
modificateur après import
sert à récupérer / utiliser les champs statiques d'une classe. Un domaine dans lequel j'utilise import static
est de récupérer des constantes d'une classe. Nous pouvons également appliquer import static
des méthodes statiques. Assurez-vous de taper import static
car static import
c'est faux.
Ce qui est static import
en Java - JavaRevisited - Une très bonne ressource pour en savoir plusimport static
.