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

la principale différence est Readablity , Constant.USER_NAME est moins lisible par rapport à USER_NAME .

À Partir De Documentation :

utilisé de manière appropriée, l'importation statique peut rendre votre programme plus lisible, en supprimant le boilerplate de répétition des noms de classe.

mais dans tous les cas, essayer d'éviter de faire

import static B.Constant.*;

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

- je utiliser des importations très rarement et seulement là où ils ont fait un peu le code plus facile à suivre.

selon oracle:

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

alors quand devez-vous utiliser l'importation statique? Très parcimonieusement! Utiliser seulement lorsque vous seriez sinon tenté de déclarer des copies locales de constantes, ou abus héritage (L'Interface constante Antipattern). Dans d'autres mots, utilisez-le lorsque vous avez besoin d'un accès fréquent aux membres statiques de une ou deux classes. Si vous abusez de la fonctionnalité d'importation statique, il peut rendre votre programme illisible et non durable, polluant son namespace avec tous les membres statiques que vous importez. Lecteurs de votre code (y compris vous, quelques mois après que vous l'avez écrit) ne saura pas classe membre statique. L'importation de tous les membres statiques à partir d'une classe peut être particulièrement nuisible à la lisibilité; si vous avez besoin seulement un ou deux membres, les importer individuellement. Utilisé de manière appropriée, l'importation statique peut rendre votre programme plus lisible, en supprimant passe-partout de la 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 éléments statiques d'une ou deux classes
• utilisé de manière appropriée, statique l'importation peut rendre votre programme plus lisible

et le commentateur @Donal Fellows, dit à juste titre que l'utilisation d'un IDE pour gérer les importations statiques est moins risquée. Je suis d'accord que les IDE modernes ont parcouru un long chemin et vont éliminer beaucoup des douleurs de gérer les dépendances et les appels de méthode de traçage à un parent.

Par exemple toutes les méthodes de la classe Math sont statiques un nous appelons tous de Mathématiques.mathod().Mais si nous importons classe de mathématiques comme ceci: import static java.lang.Math.*; nous n'avons pas à ajouter les mathématiques 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);
    }
}

Static imports évitez les membres statiques admissibles avec des noms de classe.

une fois que le membre statique est importé, vous pouvez l'utiliser dans votre code sans le préfixe de 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;
}

Statique importations sont utilisés pour économiser votre temps et de dactylographie. Si vous détestez taper la même chose encore et encore alors vous pouvez trouver de telles importations intéressantes.

le import permet au programmeur java d'accéder aux classes d'un paquet sans qualification de paquet.

la caractéristique tatic import permet d'accéder aux éléments statiques d'une classe sans 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

afin d'accéder aux éléments statiques, il est nécessaire de qualifier les références avec la classe dont elles proviennent. Par exemple, il faut dire:

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

vous pouvez vouloir éviter l'utilisation inutile de membres de classe statique comme les mathématiques. et le Système. Pour cette utilisation importation statique. Par exemple, le code ci-dessus, lorsqu'il est modifié en utilisant l'importation statique, est modifié comme suit:

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. Aussi garder une chose à l'esprit ici. L'importation statique ambiguë n'est pas autorisée. c'est à dire si vous avez importés de java.lang.Mathématique.PI et vous voulez importer mypackage.Someclass.PI, le compilateur va lancer une erreur. Ainsi, vous ne pouvez importer QU'un seul PI membre.

Aujourd'hui, nous avons rencontré un grand désavantage des importations statiques. Juste le partage ci-dessous.

1. XXXConsts.java avait EVENT_ID (EVENT_ID = "EVENT_ID") qui était statiquement importé dans une classe XXXComceteImpl.java qui s'étend D'AbstractService.java
2. XXXZeloImpl.java qui s'étend D'AbstractService.java voulais EVENT_ID = "id de l'événement". Ainsi EVENT_ID = "eventId" a été déclaré dans AbstractService.Java.
3. Maintenant #1 a été cassé par la EVENT_ID dans XXXComceteImpl.java faisait référence à EVENT_ID dans AbstractService.java
4. peut être le nom de EVENT_ID = "eventId" aurait dû être différent.
5. Note :