Java Language
Compilateur Java - 'javac'

Remarques

La commande 'javac' - démarrer

Exemple simple

En supposant que "HelloWorld.java" contient la source Java suivante:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello world!");
    }
}

(Pour une explication du code ci-dessus, reportez-vous à la section Démarrer avec le langage Java .)

Nous pouvons compiler le fichier ci-dessus en utilisant cette commande:

$ javac HelloWorld.java 

Cela produit un fichier appelé "HelloWorld.class", que nous pouvons alors exécuter comme suit:

$ java HelloWorld
Hello world!

Les points clés à noter dans cet exemple sont les suivants:

1. Le nom de fichier source "HelloWorld.java" doit correspondre au nom de la classe dans le fichier source ... qui est HelloWorld . S'ils ne correspondent pas, vous obtiendrez une erreur de compilation.
2. Le nom de fichier du bytecode "HelloWorld.class" correspond au nom de la classe. Si vous deviez renommer "HelloWorld.class", vous obtiendriez une erreur lorsque vous avez essayé de l'exécuter.
3. Lorsque vous exécutez une application Java utilisant java , vous indiquez le nom de classe NOT le nom de fichier du bytecode.

Exemple avec des packages

Le code Java le plus pratique utilise des packages pour organiser l'espace de noms des classes et réduire le risque de collision de noms de classe accidentels.

Si nous voulions déclarer la classe HelloWorld dans un paquet appelé com.example , le fichier "HelloWorld.java" contiendrait la source Java suivante:

package com.example;

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello world!");
    }
}

Ce fichier de code source doit être stocké dans une arborescence de répertoires dont la structure correspond au nom du package.

.    # the current directory (for this example)
|
 ----com
     |
      ----example
          |
           ----HelloWorld.java

Nous pouvons compiler le fichier ci-dessus en utilisant cette commande:

$ javac com/example/HelloWorld.java 

Cela produit un fichier appelé "com / example / HelloWorld.class"; c'est-à-dire qu'après la compilation, la structure du fichier devrait ressembler à ceci:

.    # the current directory (for this example)
|
 ----com
     |
      ----example
          |
           ----HelloWorld.java
           ----HelloWorld.class

Nous pouvons alors exécuter l'application comme suit:

$ java com.example.HelloWorld
Hello world!

Les points supplémentaires à noter de cet exemple sont les suivants:

1. La structure de répertoire doit correspondre à la structure du nom du package.
2. Lorsque vous exécutez la classe, le nom complet de la classe doit être fourni. c'est-à-dire "com.example.HelloWorld" pas "HelloWorld".
3. Vous n'avez pas besoin de compiler et d'exécuter du code Java à partir du répertoire en cours. Nous le faisons juste ici pour l'illustrer.

Compiler plusieurs fichiers à la fois avec 'javac'.

Si votre application se compose de plusieurs fichiers de code source (et la plupart le font!), Vous pouvez les compiler un par un. Alternativement, vous pouvez compiler plusieurs fichiers en même temps en listant les noms de chemins:

$ javac Foo.java Bar.java

ou en utilisant la fonctionnalité générique de nom de fichier de votre shell de commande ....

$ javac *.java
$ javac com/example/*.java
$ javac */**/*.java #Only works on Zsh or with globstar enabled on your shell

Cela compilera tous les fichiers source Java dans le répertoire courant, dans le répertoire "com / example" et récursivement dans les répertoires enfants respectivement. Une troisième alternative consiste à fournir une liste des noms de fichiers source (et des options du compilateur) en tant que fichier. Par exemple:

$ javac @sourcefiles

où le fichier sourcefiles contient:

Foo.java
Bar.java
com/example/HelloWorld.java

Note: compiler du code comme celui-ci est approprié pour les petits projets d'une personne et pour les programmes ponctuels. Au-delà, il est conseillé de sélectionner et d'utiliser un outil de compilation Java. Alternativement, la plupart des programmeurs utilisent un IDE Java (par exemple NetBeans , eclipse , IntelliJ IDEA ) qui offre un compilateur intégré et la création incrémentale de "projets".

Options «javac» couramment utilisées

Voici quelques options pour la commande javac susceptibles de vous être utiles

• L'option -d définit un répertoire de destination pour l'écriture des fichiers ".class".
• L'option -sourcepath définit un chemin de recherche de code source.
• Le -cp ou -classpath option permet de définir le chemin de recherche pour trouver des classes externes et compilées précédemment. Pour plus d'informations sur le chemin de classe et sa spécification, reportez-vous à la rubrique The Classpath Topic.
• L'option -version imprime les informations de version du compilateur.

Une liste plus complète des options du compilateur sera décrite dans un exemple distinct.

Les références

La référence définitive pour la commande javac est la page de manuel Oracle pour javac .

Compiler pour une version différente de Java

Le langage de programmation Java (et son exécution) a subi de nombreuses modifications depuis sa sortie depuis sa publication initiale. Ces changements incluent:

• Changements dans la syntaxe et la sémantique du langage de programmation Java
• Modifications apportées aux API fournies par les bibliothèques de classes standard Java.
• Modifications apportées au jeu d'instructions Java (bytecode) et au format classfile.

À quelques exceptions près (par exemple, le mot clé enum , les modifications apportées à certaines classes "internes", etc.), ces modifications sont rétrocompatibles.

• Un programme Java compilé à l'aide d'une ancienne version de la chaîne d'outils Java s'exécute sur une plate-forme Java plus récente sans recompilation.
• Un programme Java écrit dans une version antérieure de Java sera compilé avec un nouveau compilateur Java.

Compiler l'ancien Java avec un compilateur plus récent

Si vous devez (re) compiler un code Java plus ancien sur une plate-forme Java plus récente pour qu'il s'exécute sur la nouvelle plate-forme, vous n'avez généralement pas besoin d'indiquer de compilation spéciale. Dans quelques cas (par exemple, si vous avez utilisé enum comme identifiant), vous pouvez utiliser l'option -source pour désactiver la nouvelle syntaxe. Par exemple, compte tenu de la classe suivante:

public class OldSyntax {
    private static int enum;  // invalid in Java 5 or later
}

les éléments suivants sont requis pour compiler la classe à l'aide d'un compilateur Java 5 (ou ultérieur):

$ javac -source 1.4 OldSyntax.java

Compiler pour une plate-forme d'exécution plus ancienne

Si vous devez compiler Java pour qu'il fonctionne sur une plate-forme Java plus ancienne, l'approche la plus simple consiste à installer un JDK pour la version la plus ancienne à prendre en charge et à utiliser le compilateur JDK dans vos versions.

Vous pouvez également compiler avec un compilateur Java plus récent, mais il y a des complications. Tout d'abord, il existe des conditions préalables importantes qui doivent être satisfaites:

• Le code que vous compilez ne doit pas utiliser les constructions de langage Java qui n'étaient pas disponibles dans la version de Java que vous ciblez.
• Le code ne doit pas dépendre des classes Java standard, des champs, des méthodes, etc., qui n'étaient pas disponibles sur les anciennes plates-formes.
• Les bibliothèques tierces dont dépend le code doivent également être construites pour l'ancienne plate-forme et disponibles à la compilation et à l'exécution.

Étant donné que les conditions préalables sont remplies, vous pouvez recompiler le code pour une plate-forme plus ancienne en utilisant l'option -target . Par exemple,

$ javac -target 1.4 SomeClass.java

compilera la classe ci-dessus pour produire des bytecodes compatibles avec JVM Java 1.4 ou ultérieur. (En fait, l'option -source implique un -target compatible, donc javac -source 1.4 ... aurait le même effet. La relation entre -source et -target est décrite dans la documentation Oracle.)

Cela dit, si vous utilisez simplement -target ou -source , vous compilerez toujours avec les bibliothèques de classes standard fournies par le JDK du compilateur. Si vous ne faites pas attention, vous pouvez vous retrouver avec des classes avec la version correcte du bytecode, mais avec des dépendances sur des API non disponibles. La solution consiste à utiliser l'option -bootclasspath . Par exemple:

$ javac -target 1.4 --bootclasspath path/to/java1.4/rt.jar SomeClass.java

compilera avec un autre ensemble de bibliothèques d'exécution. Si la classe compilée a des dépendances (accidentelles) sur les nouvelles bibliothèques, cela vous donnera des erreurs de compilation.