Paquets et importations statiques en Java

Le main() La méthode vérifie d'abord qu'un seul argument de ligne de commande a été spécifié. Si la vérification réussit, elle transmet cet argument à Audio.newAudio() et attribue le retour Audio référence de l'objet à une variable locale nommée audio. main() procède ensuite à la vérification que audio n'est pas nul et (dans ce cas) interroger le Audio objet, générant les valeurs d'échantillonnage du clip audio ainsi que sa fréquence d'échantillonnage.

Copiez la liste 3 dans un fichier nommé UseAudio.java et placez ce fichier dans le même répertoire que le ca répertoire que vous avez précédemment créé. Ensuite, exécutez la commande suivante pour compiler UseAudio.java:

javac UseAudio.java

Si tout se passe bien, vous devriez observer UseAudio.class dans le répertoire courant.

Exécutez la commande suivante pour exécuter UseAudio contre un fichier WAV fictif nommé audio.wav:

java UseAudio audio.wav

Vous devriez observer le résultat suivant :

Samples

Sample Rate: 0

Supposons que UseAudio.java n'était pas situé dans le même répertoire que ca. Comment compiler ce fichier source et exécuter l'application résultante ? La réponse est d'utiliser le classpath.

Le chemin de classe Java

Le Chemin de classe Java est une séquence de packages dans laquelle la machine virtuelle Java (JVM) recherche des types de référence. Elle est spécifiée via le -classpath (ou -cp) option utilisée pour démarrer la JVM ou, lorsqu'elle n'est pas présente, la CLASSPATH variable d'environnement.

Supposons (sur une plate-forme Windows) que la bibliothèque audio soit stockée dans C:audio et cela UseAudio.java est stocké dans C:UseAudioqui est actuel. Spécifiez les commandes suivantes pour compiler le code source et exécuter l'application :

javac -cp ../audio UseAudio.java
java -cp ../audio;. UseAudio audio.wav

Le personnage d'époque dans le java-la ligne de commande préfixée représente le répertoire actuel. Elle doit être spécifiée pour que la JVM puisse localiser UseAudio.class.

Sujets supplémentaires du package

Le langage Java comprend un protected mot-clé, qui est utile dans un contexte de package. De plus, les packages peuvent être distribués dans des fichiers JAR. De plus, la JVM suit un ordre de recherche spécifique lors de la recherche de packages pour les types de référence (que ces packages soient ou non stockés dans des fichiers JAR). Nous explorerons ces sujets ensuite.

Accès protégé

Le protected Le mot-clé attribue le niveau d'accès protégé à un membre de classe, tel qu'un champ ou une méthode (par exemple, protected void clear()). Déclarer un membre de classe protected rend le membre accessible à tout le code de n'importe quelle classe située dans le même package et aux sous-classes quels que soient leurs packages.

Joshua Bloch explique la raison pour laquelle il faut accorder un accès protégé aux membres de la classe dans son livre, Java efficace, deuxième édition (« Élément 17 : concevoir et documenter pour l'héritage ou l'interdire »). Ce sont des crochets dans le fonctionnement interne d'une classe pour permettre aux programmeurs « d'écrire des sous-classes efficaces sans effort excessif ». Consultez le livre pour plus d'informations.

Fichiers JAR

Distribuer un package en spécifiant des instructions pour créer la structure de répertoire nécessaire avec les fichiers de classe du package (et des instructions sur les fichiers de classe à stocker dans quels répertoires) serait une tâche fastidieuse et sujette aux erreurs. Heureusement, les fichiers JAR offrent une bien meilleure alternative.

UN Fichier JAR (archive Java) est une archive ZIP avec un .jar extension (au lieu de la .zip extension). Il comprend une extension spéciale META-INF répertoire contenant manifest.mf (un fichier spécial qui stocke des informations sur le contenu du fichier JAR) et une structure de répertoire hiérarchique qui organise les fichiers de classe.

Vous utilisez les JDK jar outil pour créer et maintenir un fichier JAR. Vous pouvez également afficher la table des matières du fichier JAR. Pour vous montrer à quel point il est facile d'utiliser cet outil, nous allons créer un audio.jar fichier qui stocke le contenu du ca.javajeff.audio package. Nous accéderons ensuite à ce fichier JAR lors de l'exécution UseAudio.class. Créer audio.jar comme suit:

Tout d'abord, assurez-vous que le répertoire actuel contient le fichier précédemment créé ca / javajeff / audio hiérarchie des répertoires, et cela audio contient audio.class et WavReader.class.

Deuxièmement, exécutez la commande suivante :

jar cf audio.jar cajavajeffaudio*.class

Le c L'option signifie « créer une nouvelle archive » et la f L'option signifie « spécifier le nom du fichier d'archive ».

Vous devriez maintenant trouver un audio.jar fichier dans le répertoire courant. Prouvez-vous que ce fichier contient les deux fichiers de classe en exécutant la commande suivante, où le t option signifie « liste des matières » :

jar tf audio.jar

Tu peux courir UseAudio.class en ajoutant audio.jar à son classpath. Par exemple, en supposant que audio.jar se trouve dans le même répertoire que UseAudio.classtu peux courir UseAudio sous Windows via la commande suivante :

java -classpath audio.jar;. UseAudio

Pour plus de commodité, vous pouvez spécifier la version la plus courte -cp au lieu du plus long -classpath.

Recherche de paquets pour les types de référence

Les nouveaux venus dans les packages Java sont souvent frustrés par le message « aucune définition de classe trouvée » et d’autres erreurs. Cette frustration peut être en partie évitée en comprenant comment la JVM recherche les types de référence. Pour comprendre ce processus, vous devez comprendre que le compilateur est une application Java spéciale qui s’exécute sous le contrôle de la JVM. Il existe également deux formes de recherche : la recherche à la compilation et la recherche à l’exécution.

Recherche au moment de la compilation

Lorsque le compilateur rencontre une expression de type (comme un appel de méthode) dans le code source, il doit localiser la déclaration de ce type pour vérifier que l'expression est légale. Par exemple, il peut vérifier qu'une méthode existe dans la classe du type, dont les types de paramètres correspondent aux types des arguments passés dans l'appel de méthode.

Le compilateur recherche d'abord les packages de la plateforme Java (dans rt.jar et d'autres fichiers JAR), qui contiennent les types de bibliothèque de classes standard de Java (tels que java.lang's System classe). Il recherche ensuite les packages d'extension pour les types d'extension. Si le -sourcepath l'option est spécifiée au démarrage javacle compilateur recherche les fichiers sources du chemin indiqué.

Sinon, le compilateur recherche dans le chemin de classe (de gauche à droite) le premier fichier de classe ou le fichier source contenant le type. Si aucun chemin de classe n'est présent, la recherche s'effectue dans le répertoire courant. Si aucun package ne correspond ou si le type est toujours introuvable, le compilateur signale une erreur. Sinon, il enregistre les informations du package dans le fichier de classe.

Recherche d'exécution

Lorsque le compilateur ou toute autre application Java s'exécute, la JVM rencontre des types et doit charger leurs fichiers de classe associés via un code spécial appelé chargeur de classe. La JVM utilisera les informations de package précédemment stockées associées au type rencontré dans une recherche du fichier de classe de ce type.

La JVM recherche les packages de la plateforme Java, suivis des packages d'extension, puis du chemin de classe ou du répertoire actuel (lorsqu'il n'y a pas de chemin de classe) pour le premier fichier de classe contenant le type. Si aucun package ne correspond ou si le type est introuvable, une erreur « aucune définition de classe trouvée » est signalée. Sinon, le fichier de classe est chargé en mémoire.

Importation statique de membres statiques

Dans Effective Java, deuxième édition, article 19Joshua Bloch mentionne que les développeurs Java ne devraient utiliser des interfaces que pour déclarer des types. Nous ne devrions pas utiliser d'interfaces pour déclarer interfaces constantesqui sont des interfaces qui n'existent que pour exporter des constantes. Liste 4 Switchable L'interface constante fournit un exemple.

Liste 4. Une interface constante (Switchable.java)

public interface Switchable
{
   boolean OFF = false;
   boolean ON = true;
}

Les développeurs ont recours à des interfaces constantes pour éviter d'avoir à préfixer le nom de la constante avec le nom de son type de référence (par exemple, Math.PI). Par exemple, considérons la liste 5 Light classe, qui implémente le Switchable interface pour que le développeur soit libre de spécifier des constantes OFF et ON sans avoir à inclure les préfixes de classe (s'ils ont été déclarés dans une classe).

Liste 5. Light implémente Switchable (Light.java, version 1)

public class Light implements Switchable
{
   private boolean state = OFF;

   public void printState()
   {
      System.out.printf("state = %s%n", (state == OFF) ? "OFF" : "ON");
   }

   public void toggle()
   {
      state = (state == OFF) ? ON : OFF;
   }
}

Une interface constante fournit des constantes destinées à être utilisées dans l'implémentation d'une classe. En tant que détail d'implémentation, vous ne devez pas divulguer de constantes dans l'API exportée de la classe, car elles pourraient dérouter les autres utilisateurs de votre classe. De plus, pour préserver la compatibilité binaire, vous vous engagez à les prendre en charge, même lorsque la classe ne les utilise plus.

Importations statiques

Pour satisfaire le besoin d'interfaces constantes tout en évitant les problèmes imposés par leur utilisation, Java 5 a introduit importations statiques. Cette fonctionnalité de langage peut être utilisée pour importer les membres statiques d'un type de référence. Elle est implémentée via le import static déclaration dont la syntaxe apparaît ci-dessous :

import static packagespec . typename . ( staticmembername | * );

Placement static après import distingue cette instruction d'une instruction d'importation classique. La syntaxe est similaire à celle de l'instruction d'importation classique. import Déclaration en termes de liste standard séparée par des points de noms de paquets et de sous-paquets. Vous pouvez importer soit un seul nom de membre statique, soit tous les noms de membres statiques (grâce à l'astérisque). Considérez les exemples suivants :

import static java.lang.Math.*;   // Import all static members from Math.
import static java.lang.Math.PI;  // Import the PI static constant only.
import static java.lang.Math.cos; // Import the cos() static method only.

Une fois que vous les avez importés, vous pouvez spécifier des membres statiques sans avoir à les préfixer avec leurs noms de type. Par exemple, après avoir spécifié la première ou la troisième importation statique, vous pouvez spécifier cos directement, comme dans (>

double
      cosine = cos(angle);

Pour corriger la liste 5 afin qu'elle ne dépende plus de implements Switchablenous pouvons insérer une importation statique, comme démontré dans la liste 6.

Listing 6. Une importation statique améliore l'implémentation de Switchable (Light.java, version 2)

package foo;

import static foo.Switchable.*;

public class Light
{
   private boolean state = OFF;

   public void printState()
   {
      System.out.printf("state = %s%n", (state == OFF) ? "OFF" : "ON");
   }

   public void toggle()
   {
      state = (state == OFF) ? ON : OFF;
   }
}

La liste 6 commence par un package foo; car vous ne pouvez pas importer de membres statiques à partir d'un type situé dans le package sans nom. Ce nom de package apparaît dans le cadre de l'importation statique suivante :

import static
      foo.Switchable.*;

À quoi faut-il faire attention lors de l'utilisation d'importations statiques

Il existe deux précautions supplémentaires concernant les importations statiques.

Tout d'abord, lorsque deux importations statiques importent le membre portant le même nom, le compilateur signale une erreur. Par exemple, supposons que le package physics contient un Math classe identique à java.lang's Math classe dans la mesure où elle implémente le même PI méthodes constantes et trigonométriques. Lorsqu'il est confronté au fragment de code suivant, le compilateur signale des erreurs car il ne peut pas déterminer si java.lang.Mathou physics.Math's PI la constante est en cours d'accès et cos() la méthode est appelée :

import static java.lang.Math.cos;
import static physics.Math.cos;

double angle = PI;
System.out.println(cos(angle));

Deuxièmement, l'utilisation excessive d'importations statiques pollue l'espace de noms du code avec tous les membres statiques que vous importez, ce qui peut rendre votre code illisible et impossible à maintenir. De plus, toute personne lisant votre code pourrait avoir du mal à déterminer de quel type provient un membre statique, en particulier lors de l'importation de tous les noms de membres statiques d'un type.

Conclusion

Les packages vous aident à créer des bibliothèques réutilisables de types de référence avec leurs méthodes. Si vous appelez une méthode (qu'elle soit ou non empaquetée dans une bibliothèque) avec un argument illégal (comme un index négatif pour un tableau), vous rencontrerez probablement une exception Java.