web-dev-qa-db-fra.com

Y a-t-il des avantages à utiliser l'importation statique par rapport à l'importation?

Considérons le cours suivant

public final class Constant {
  public static final String USER_NAME="user1";
  //more constant here
}

Cette classe dans le paquet B.

Maintenant, je vais utiliser ceci dans le paquet A. Envisagez de suivre deux manières qui peuvent être utilisées.

Méthode 1- utilisez import B.Constant 

import B.Constant;

public class ValidateUser {
public static void main(String[] args) {
   if(Constant.USER_NAME.equals("user1")){

   }
  }
 }

Méthode 2- utilisez import static B.Constant.USER_NAME;

import static B.Constant.USER_NAME;

public class ValidateUser {
public static void main(String[] args) {
   if(USER_NAME.equals("user1")){

   }
 }
}

Ma question est la suivante: existe-t-il une différence ou un avantage entre une importation normale et une importation statique dans ce cas?

javaimportstatic-import
21
Ruchira Gayan Ranaweera

La seule différence entre une import normale et un import static est que ce dernier est destiné à déplacer les membres static d'une autre classe ou interface - en particulier constantes - dans la portée. C'est à vous de décider si vous l'utilisez. Je l’aime bien parce qu’il garde le corps de la classe plus court, mais YMMV.

Leur utilisation ne présente aucun avantage en termes de performances ni de pénalité (sauf éventuellement lors de la compilation, comme si vous en teniez à cela), car ils sont compilés dans un code unique identique.

28
Donal Fellows

La principale différence est Readablity, Constant.USER_NAME est moins lisible que USER_NAME.

De Documentation :

Utilisée de manière appropriée, l’importation statique peut rendre votre programme plus lisible, en supprimant le passe-partout de la répétition des noms de classe.

Mais dans tous les cas, essayez d'éviter de faire 

import static B.Constant.*;

car il peut polluer son espace de noms avec tous les membres statiques que vous importez.

20
Sajan Chandran

J'utilise très rarement les importations statiques et uniquement lorsqu'elles facilitent un peu la compréhension du code.

Selon Oracle:

http://docs.Oracle.com/javase/1.5.0/docs/guide/language/static-import.html

Alors, quand devriez-vous utiliser l'importation statique? Très économiquement! Utilisez-le seulement quand vous seriez autrement tenté de déclarer des copies locales de constantes, ou de abus héritage (Constant Interface Antipattern). En d'autre mots, utilisez-le lorsque vous avez besoin d'un accès fréquent à des membres statiques à partir de une ou deux classes. Si vous abusez de la fonctionnalité d'importation statique, elle peut rendre votre programme illisible et incontrôlable, en polluant ses espace de noms avec tous les membres statiques que vous importez. Lecteurs de votre code (y compris vous, quelques mois après l'avoir écrite) ne saura pas lequel classe un membre statique vient de. Importation de tous les membres statiques d'une classe peut être particulièrement préjudiciable à la lisibilité; si tu as besoin un ou deux membres seulement, importez-les individuellement. Utilisé de manière appropriée, L'importation statique peut rendre votre programme plus lisible, en supprimant le passe-partout de répétition des noms de classe.

Les points importants à noter ici: 

  • Utilisez-le lorsque vous avez besoin d'un accès fréquent à des membres statiques d'une ou deux classes.
  • Utilisée correctement, l'importation statique peut rendre votre programme plus lisible

Et commenter @Donal Fellows, affirme à juste titre que l'utilisation d'un IDE pour gérer les importations statiques est moins risquée. Je conviens que les IDE modernes ont parcouru un long chemin et résoudront le problème de la gestion des dépendances et des appels de méthodes de suivi à un parent. 

9
Husman

Par exemple, toutes les méthodes de la classe Math sont statiques et appelées Math.mathod (). Mais si nous importons une classe Math comme ceci: import static Java.lang.Math.*; Il n'est pas nécessaire d'ajouter Math avant la méthode:

import static Java.lang.Math.*;

public class Program {

    public static void main(String args[]) {

        System.out.println(sqrt(25));
        System.out.println(log(100));
        System.out.println(PI);
    }
}
4
Melih Altıntaş

Importations statiques vous permettent d'éviter de qualifier des membres statiques avec des noms de classe.

Une fois le membre statique importé, vous pouvez l'utiliser dans votre code sans le préfixe du nom de classe.

Bon exemple:

import static sample.SampleStaticValues.NUM_ZERO;
…

enum OddEven {odd,even}


//need not do SampleConstants.NUM_ZERO due to static import feature
if(num % 2 == NUM_ZERO){
   System.out.println("The num " + num + " is: " + OddEven.even);
}

  package sample;
  public class SampleStaticValues {
  public static int NUM_ZERO = 0;
  public static int NUM_ONE = 0;
}
2
Maxim Shoustin

Les importations statiques permettent d'économiser votre temps et votre saisie. Si vous détestez taper la même chose encore et encore, alors vous pourrez trouver de telles importations intéressantes.

Import permet au programmeur Java d'accéder aux classes d'un paquet sans qualification de paquet.

La fonctionnalité static import permet d'accéder aux membres statiques d'une classe sans la qualification de classe.

Permet de comprendre cela à l'aide des exemples ci-dessous:

Exemple 1: sans importations statiques

class Demo1{
   public static void main(String args[])
   {
      double var1= Math.sqrt(5.0);
      double var2= Math.tan(30);
      System.out.println("Square of 5 is:"+ var1);
      System.out.println("Tan of 30 is:"+ var2);
   }
}

Sortie:

Square of 5 is:2.23606797749979
Tan of 30 is:-6.405331196646276

Exemple 2: utilisation d'importations statiques

import static Java.lang.System.out;
import static Java.lang.Math.*;
class Demo2{
   public static void main(String args[])
   {
      //instead of Math.sqrt need to use only sqrt
      double var1= sqrt(5.0);
      //instead of Math.tan need to use only tan
      double var2= tan(30);
      //need not to use System in both the below statements
      out.println("Square of 5 is:"+var1);
      out.println("Tan of 30 is:"+var2);
   }
}

Sortie:

Square of 5 is:2.23606797749979
Tan of 30 is:-6.405331196646276
1
Rahul Agrawal

Pour accéder aux membres statiques, il est nécessaire de qualifier les références avec la classe d'origine. Par exemple, il faut dire:

double r = Math.cos(Math.PI * theta);
or
System.out.println("Blah blah blah");

Vous voudrez peut-être éviter d'utiliser inutilement des membres de classe statiques tels que Math. et système. Pour cette utilisation, importation statique. Par exemple, le code ci-dessus lorsqu'il est modifié à l'aide de l'importation statique est remplacé par:

import static Java.lang.System.out;
import static Java.lang.Math.PI;
import static Java.lang.Math.cos;
...
double r = cos(PI * theta);
out.println("Blah blah blah");
...

Alors, quel est l'avantage d'utiliser la technique ci-dessus? Le seul avantage que je vois est la lisibilité du code. Au lieu d’écrire le nom de la classe statique, on peut écrire directement le nom de la méthode ou de la variable membre . Gardez également une chose à l’esprit ici. L'importation statique ambiguë n'est pas autorisée. si vous avez importé Java.lang.Math.PI et que vous souhaitez importer mypackage.Someclass.PI, le compilateur générera une erreur. Ainsi, vous ne pouvez importer qu'un seul membre, PI.

0
SpringLearner