javac est le compilateur fourni dans le SDK permettant de compiler un fichier source .java. Ce code source est alors compilé par le compilateur javac en un langage appelé bytecode et enregistre le résultat dans un fichier dont l'extension est .class. Pour compiler une classe Livre contenue dans un fichier Livre.java on exécutera donc l'instruction suivante :

javac Livre.java

Le bytecode n'est pas directement exécutable. Il doit être interprété par une machine virtuelle Java qui le traduit en un langage adapté au système d'exploitation. Le programme java fourni dans le SDK lance une machine virtuelle pour interpreter une classe compilée. Attention : l'extension .class ne doit pas être précisée dans l'instruction d'interprétation. Pour exécuter la classe Livre compilée dans un fichier Livre.class, on écrit donc :

java Livre

En général, les fichiers contenant le code source des classes sont séparés des fichiers contenant le bytecode pour mieux structurer les différentes parties du programme. Pour que les fichier créés par une compilation le soient dans un autre répertoire on utilise l'option -d. Par exemple :

javac -d /MonRepertoire/Java/classes Livre.java

Lorsque le bytecode ne se situe pas dans le répertoire courant, il faut signaler à la commande java où il se trouve grâce à l'option classpath. Par exemple :

java -classpath /MonRepertoire/Java/classes Livre

La classe HelloWorld n'est pas exécutable dans son état actuel. Une classe exécutable est une classe qui contient une méthode spécifique (main) utilisée comme point de départ de l'exécution. La méthode main d'une classe s'écrit de la manière suivante :

public static void main(String[] args){
   //début du code à exécuter
}

Java est très bavard lorsqu'il vous signale une erreur d'exécution. Il affiche notamment ce qu'on appelle une trace de la pile d'appels qui ont amené à cette erreur. Cette liste d'appels est affichée de l'appel le plus interne à l'appel le plus externe. Pour trouver l'origine de l'erreur (si elle est dûe à votre code), parcourez cette liste jusqu'à trouver une classe de votre propre code. Le message d'erreur Java affiche également la ligne du code de l'appel. Pratique pour directement aller à la source de l'erreur. De plus, Java faisant usage de la notion d'exception, en lisant le type d'exception qui a généré l'erreur il est également possible d'en déduire l'origine. Par exemple, si NullPointerException est affichée, il y a de forte chance que vous ayez oublié d'initialiser un objet (par appel à new) avant de faire appel à un de ses attributs ou méthodes.

Vous avez vu que la méthode main possédait la signature suivante :

public static void main(String args[]) {
   ...
}

Le tableau args contient tous les arguments passés en paramètres du programme Java. Par exemple, suite à la ligne de commande

java MonProgramme texte1 127 unfichier.txt

le tableau args contiendra les élément suivants :

• args[0] : la chaîne de caractères "texte1"
• args[1] : la chaîne de caractères "127"
• args[2] : la chaîne de caractères "unfichier.txt"

Un package est un regroupement de plusieurs classes selon un thème précis. Au niveau du code source, un package n'a pas d'existence explicite, il n'est réellement créé que dès que sa première classe est compilée. Pour indiquer qu'une classe appartient à un package on utilise au tout début du fichier contenant le code source le mot-clé package . Pour assigner la classe Livre au package biliotheque, on écrira :

package bibliotheque;
public class Livre {
   //contenu de la classe
}

Un package peut être imbriqué dans un package plus général et ainsi de suite (comme des dossiers). Pour désigner un package document imbriqué dans le package bibliotheque on écrira par exemple:

package bibliotheque.document;

A la compilation, des répertoires sont créés pour correspondre aux packages des classes compilées. Les fichiers contenant le bytecode sont enregistrés dans le répertoire de leur package. Une classe est alors désignée par son nom de package, suivie d'un point puis du nom de la classe. Par exemple, pour exécuter la classe Livre on utilise l'instruction:

java bibliotheque.Livre

Pour que la référence à la classe Livre soit effective, il faut que le répertoire contenant son package soit accessible par la machine virtuelle. Il y a deux solutions pour cela:

1. Exécuter la classe à partir du répertoire contenant le répertoire bibliotheque. Dans ce cas là, le package bibliotheque et les classes qu'il contient sont directement trouvés car ils sont dans le répertoire d'exécution.
2. Exécuter la classe à partir d'un autre répertoire. Il faut alors préciser le chemin d'accès du répertoire contenant le package bibliotheque. Cela se fait en utilisant l'option -classpath comme précédemment :

java -classpath /MonRepertoire/Java/classes bibliotheque.Livre

Quand une classe fait référence à une autre classe, elle doit l'importer sauf si elles se trouvent dans le même package. Pour cela le mot-clé import est utilisé au début du fichier source, un peu comme include de C, comme dans l'exemple qui suit:

package client;

import bibliotheque.Livre;

public class Lecteur {
   Livre[] emprunte;
   ...
}

De cette manière la classe Lecteur peut utiliser la classe Livre. Il est également possible d'importer toutes les classes d'un package en utilisant le symbole * comme suit:

import bibliotheque.*;

javadoc est un autre programme du SDK qui créé une documentation automatique à partir du code source de classes Java. Cette documentation automatique décrit les membres d'une classe dans un format HTML. Pour créer tous les fichiers de documentation d'un package, on utilise javadoc comme suit:

javadoc -d <répertoire de destination> <nom des packages>

Le fichier principal de documentation est index.html créé dans le répertoire de destination.

Remarque : par défaut la commande javadoc ne généère la documentation que pour les classes et membres public, donc pensez à établir la visibilité de votre classe à public. Vous pouvez également spécifier à javadoc que vous voulez également générer la documentation pour les membres privés avec l'option -private :

javadoc -d <répertoire de destination> -private <nom des packages>

javadoc peut interpréter des commentaires spécifiques introduits dans le code source pour enrichir la documentation générée. Ces commentaires se situent juste avant la déclaration d'une classe, d'un attribut ou d'une méthode. Ils commencent par /** et se terminent par */. Ces commentaires contiennent une partie textuelle libre et des tags interprétés pour certains commentaires spécifiques.

Une collection est un objet qui référence plusieurs objets. La plupart des classes représentant des collections sont contenues dans le package java.util. Les classes de type collection implémentent des méthodes similaires pour accéder au groupe d'objets référencés. Les principales méthodes sont :

• add pour ajouter un objet à la collection
• contains pour tester si un objet appartient à la collection
• remove pour retirer un objet d'une collection
• size pour connaître la taille d'une collection

S'il existe différentes classes de collection, c'est parce que chacune présente des propriétés spécifiques :

• Les ensembles qui regroupent des objets distincts de manière non ordonnée. Par exemple, la classe java.util.HashSet.
• Les listes qui regroupent des objets selon un ordre donné. Par exemple, la classe java.util.Vector.
• Les maps qui associent à chaque objet du groupe une clé pour accéder directement à un objet. Par exemple, la classe java.util.Hashtable.

Depuis la version 1.5 du SDK, les collections sont typées, c'est-à-dire qu'on doit désormais préciser la classe des objets présents dans une collection. Par exemple, pour déclarer puis instancier une liste de chaînes de caractères, on écrira :

Vector<String> maListe;
maListe = new Vector<String>();

Le parcours d'une collection peut s'écrire de manière simplifiée dans une boucle for. Il suffit de référencer le type d'objets de la collection avec un nom de variable comme suit :

for (String s: maListe) {
   System.out.println(s);
}

Ce qui signifie ici : pour chaque String (que l'on nomme s) contenu dans maListe, on écrit l'objet sur la sortie standard. Cette boucle comptera autant d'itérations qu'il y a d'éléments dans maListe et à chaque itération, s aura pour valeur un élément de maListe.