Comment installer le JDK 15 (sur Windows, macOS et Ubuntu) et démarrer la programmation Java

Le kit de développement Java (JDK), officiellement nommé « Java Platform Standard Edition » ou « Java SE », est nécessaire pour écrire et exécuter des programmes Java.

Actuellement, l’OpenJDK développé par Oracle et la communauté Java (@ https://openjdk.java.net/) fournit une implémentation de référence officielle du JDK, gratuite et open-source.

Cet article est basé sur le JDK d’Oracle (@ https://www.oracle.com/java/) (en raison de l’héritage), qui est gratuit pour un usage personnel et de développement mais plus pour un usage commercial.

Versions du JDK

Référence : « Historique des versions de Java » @ https://en.wikipedia.org/wiki/Java_version_history.

  1. JDK Alpha et Beta (1995) : Sun Microsystem a annoncé Java le 23 septembre 1995.
  2. JDK 1.0 (janvier 1996) : Initialement appelé Oak (du nom du chêne situé à l’extérieur du bureau de James Gosling). Renommé Java 1 dans le JDK 1.0.2.
  3. JDK 1.1 (février 1997) : Introduit le modèle d’événement AWT, la classe interne, JavaBean, JDBC et RMI.
  4. J2SE 1.2 (JDK 1.2) (décembre 1998) : Re-baptisé « Java 2 » et renommé JDK en J2SE (Java 2 Standard Edition). Publication également de J2EE (Java 2 Enterprise Edition) et J2ME (Java 2 Micro Edition). Inclus JFC (Java Foundation Classes – Swing, Accessibility API, Java 2D, Pluggable Look & Feel, et Drag & Drop). Introduit également le Collection Framework et le compilateur JIT.
  5. J2SE 1.3 (JDK 1.3) (mai 2000) : Introduction de la JVM Hotspot.
  6. J2SE 1.4 (JDK 1.4) (février 2002) : Introduit l’instruction assert, l’entrée/sortie non bloquante (nio), l’API de journalisation, l’entrée/sortie d’images, Java webstart, le support des expressions régulières (regex).
  7. J2SE 5.0 (JDK 5) (septembre 2004) : Officiellement appelé 5.0 au lieu de 1.5 (en laissant tomber le 1.). Introduction des génériques, autoboxing/unboxing, annotation, enum, varargs, boucle for-each, static import. Voir « Nouvelles fonctionnalités du JDK 5 ».
  8. Java SE 6 (JDK 6) (décembre 2006) : Renommé J2SE en Java SE (Java Platform Standard Edition). Pas de nouvelles fonctionnalités de langage. Voir « Nouvelles fonctionnalités du JDK 6 ».
  9. Java SE 7 (JDK 7) (juillet 2011) : Première version après l’achat de Sun Microsystem par Oracle – aslo appelée OracleJDK. Introduit les chaînes de caractères dans l’instruction switch, les littéraux entiers binaires, l’autorisation des caractères de soulignement dans les littéraux numériques, l’inférence de type améliorée pour la création d’instance générique (ou opérateur diamant <>), la capture de plusieurs types d’exceptions et le rejet des exceptions avec une vérification de type améliorée. Voir « Nouvelles fonctionnalités du JDK 7 ».
  10. Java SE 8 LTS (JDK 8) (mars 2014) : A inclus la prise en charge des expressions Lambda, des méthodes par défaut et statiques dans les interfaces, de la collecte améliorée et du runtime JavaScript. A également intégré le sous-système graphique JavaFX. Voir « Nouvelles fonctionnalités du JDK 8 ».
  11. Java SE 9 (JDK 9) (21 septembre 2017) : A introduit la modularisation du JDK (module) dans le cadre du projet Jigsaw, le Shell Java (jshell), et plus encore. Voir « Nouvelles fonctionnalités du JDK 9 ».
  12. Java SE 10 (18.3) (JDK 10) (mars 2018) : Introduction de var pour la variable locale d’inférence de type (similaire à JavaScript). Introduction d’un versionnement des versions basé sur le temps avec deux versions par an, en mars et en septembre, désignées par YY.M. Suppression de l’outil de génération d’en-tête natif javah. Voir « Nouvelles fonctionnalités du JDK 10 ».
  13. Java SE 11 LTS (18.9) (JDK 11) (septembre 2018) : Extension de var à l’expression lambda. Normalisation du client HTTP dans java.net.http. Supporte TLS 1.3. Nettoyage du JDK et du paquet d’installation (suppression de JavaFX, JavaEE, modules CORBA, moteur JavaScript Nashorn déprécié). OracleJDK n’est plus gratuit pour une utilisation commerciale, mais OpenJDK est toujours gratuit. Voir « Nouvelles fonctionnalités du JDK 11 ».
  14. Java SE 12 (19.3) (JDK 12) (mars 2019) : Switch Expression (aperçu). Voir « Nouvelles fonctionnalités du JDK 12 ».
  15. Java SE 13 (19.9) (JDK 13) (septembre 2019) : Expression de commutation (aperçu), bloc de texte à plusieurs lignes (aperçu). Voir « Nouvelles fonctionnalités du JDK 13 ».
  16. Java SE 14 (20.3) (JDK 14) (mars 2020) : Records (aperçu)
  17. Java SE 15 LTS (20.9) (JDK 15) (septembre 2020) :

« JDK » ou « JRE »?

JRE (Java Runtime), qui comprend une machine virtuelle Java et des bibliothèques de base, est nécessaire pour exécuter des programmes Java. JDK (Java Development Kit), qui comprend JRE plus les outils de développement (tels que le compilateur et le débogueur), est nécessaire pour écrire ainsi que pour exécuter des programmes Java. En d’autres termes, JRE est un sous-ensemble de JDK. Puisque vous êtes censé écrire des programmes Java au lieu de simplement exécuter des programmes Java, vous devez installer JDK, qui comprend JRE.

Comment installer JDK sur Windows

Étape 0 : Désinstaller la ou les anciennes versions de JDK/JRE

Je vous recommande d’installer uniquement la dernière version de JDK. Bien que vous puissiez installer plusieurs versions de JDK/JRE simultanément, c’est désordonné.

Si vous avez précédemment installé une ou plusieurs anciennes versions de JDK/JRE, désinstallez-les TOUTES. Allez dans « Panneau de configuration » ⇒ (facultatif) « Programmes » ⇒ « Programmes et fonctionnalités » ⇒ Désinstallez TOUS les programmes commençant par « Java », tels que « Java SE Development Kit … », « Java SE Runtime … », « Java X Update … », etc.

Etape 1 : Télécharger le JDK
  1. Voir le site de téléchargement du JDK (ou Java SE) @ https://www.oracle.com/java/technologies/javase-downloads.html.
  2. Sous « Oracle JDK », cliquez sur « JDK Download ».
  3. Télécharger le « Windows x64 Installer » (par ex, « jdk-15.0.{x}_windows-x64_bin.exe » – environ 159 Mo), où {x} est un numéro de mise à jour qui change rapidement.
Étape 2 : installer JDK

Exécutez le programme d’installation téléchargé. Acceptez les valeurs par défaut et suivez les instructions à l’écran pour terminer l’installation. Par défaut, JDK est installé dans le répertoire « C:\Program Files\Java\jdk-15.0.{x}« , où {x} désigne le numéro de mise à jour.

Lancez « l’explorateur de fichiers ». Naviguez jusqu’à "C:\Program Files\Java" pour inspecter les répertoires. Prenez note de votre répertoire installé JDK jdk-15.0.{x}, en particulier du numéro de mise à jour {x} dont vous aurez besoin à l’étape suivante.

Je ferai référence au répertoire installé du JDK comme <JAVA_HOME>, ci-après, dans cet article (correspondant à la variable d’environnement %JAVA_HOME% sous Windows ou $JAVA_HOME sous Unix/macOS).

Étape 3 : (SKIP pour JDK 15) Inclure le répertoire « bin » de JDK dans le PATH

L’invite de commande de Windows (CMD) recherche les programmes exécutables dans le répertoire courant et dans les répertoires listés dans la variable d’environnement PATH.

Les programmes de JDK (tels que le compilateur Java "javac.exe » et le runtime Java "java.exe« ) résident dans le sous-répertoire « bin » du répertoire installé de JDK. Le « bin » de JDK doit être ajouté dans le PATH.

Avant JDK 15, vous devez explicitement ajouter le « bin » de JDK dans le PATH. À partir du JDK 15, le processus d’installation ajoute le répertoire « C:\Program Files\Common Files\Oracle\Java\javapath » au PATH. Le répertoire « javapath » est un lien vers « javapath_target_xxxxxx« , qui contient une copie des programmes JDK suivants :

  • java.exe : Java Runtime
  • javac.exe : Compilateur Java
  • javaw.exe : Moteur d’exécution Java pour Windows sans console
  • jshell.exe : Java Command-line Shell (depuis le JDK 10) – une boucle de lecture-évaluation-impression (REPL) qui évalue les déclarations, les énoncés et les expressions au fur et à mesure de leur saisie et affiche immédiatement les résultats.

La liaison est utilisée pour que vous puissiez conserver plusieurs copies (versions) du JDK.

Pour modifier la PATH variable d’environnement dans Windows 10 :

  1. Lancez « Panneau de configuration » ⇒ (facultatif) « Système et sécurité » ⇒ « Système » ⇒ Cliquez sur « Paramètres système avancés » dans le volet de gauche.
  2. Passez à l’onglet « Avancé » ⇒ Cliquez sur le bouton « Variables d’environnement ».
  3. Sous « Variables système » (le volet inférieur), faites défiler vers le bas pour sélectionner la variable « Chemin » ⇒ Cliquez sur « Modifier… ».
  4. Pour Windows 10 plus récent:
    Vous devriez voir un TABLEAU répertoriant toutes les entrées PATH existantes (sinon, passez à l’étape suivante). Cliquez sur « New » ⇒ Cliquez sur « Browse » et naviguez jusqu’au répertoire « bin » de votre JDK, c’est-à-dire , « c:\Program Files\Java\jdk-15.0.{x}\bin« , où {x} est le numéro de mise à jour de votre installation ⇒ Sélectionnez « Move Up » pour déplacer cette entrée tout en haut.
  5. Pour les anciens Windows 10 (Il est temps de changer d’ordinateur !):
    (ATTENTION : lisez ce paragraphe 3 fois avant de faire cette étape ! N’appuyez pas sur « Appliquer » ou « OK » avant d’être sûr à 101%. Il n’y a pas d’UNDO ! !!)
    (Pour être SÛR, copiez le contenu de la « Valeur variable » dans le Bloc-notes avant de la modifier ! !!)
    Dans le champ « Valeur variable », APPLIQUEZ « c:\Program Files\Java\jdk-15.0.{x}\bin« . (où {x} est le numéro de mise à jour de votre installation) DEVANT tous les répertoires existants, suivi d’un point-virgule (;) pour séparer le répertoire bin du JDK du reste des répertoires existants. NE SUPPRIMEZ PAS les entrées existantes ; sinon, certaines applications existantes pourraient ne pas fonctionner.
    Variable name : PATHVariable value : c:\Program Files\Java\jdk-15.0.{x}\bin;

Vous devez redémarrer CMD pour que les nouveaux paramètres d’environnement prennent effet.

Etape 4 : Vérifier l’installation du JDK

Lancez un CMD via l’un des moyens suivants :

  1. Cliquez sur le bouton « Rechercher » ⇒ Tapez « cmd » ⇒ Choisissez « Invite de commande », ou
  2. Cliquez avec le bouton droit de la souris sur le bouton « Démarrer » ⇒ exécutez…. ⇒ entrez « cmd », ou
  3. Cliquez sur le bouton « Démarrer » ⇒ Système Windows ⇒ Invite de commande

Issuez les commandes suivantes pour vérifier votre installation JDK :

  1. (Sautez pour JDK 15) Émettez la commande « path » pour lister le contenu de la variable d’environnement PATH. Vérifiez que le « bin » de votre JDK est répertorié dans la PATH
    pathPATH=c:\Program Files\Java\jdk-15.0.{x}\bin;other entries...
  2. Il faut lancer les commandes suivantes pour vérifier que JDK/JRE sont bien installés et afficher leur version :
    // Display the JDK versionjavac -versionjavac 15.0.1// Display the JRE versionjava -versionjava version "15.0.1" 2020-10-20Java(TM) SE Runtime Environment (build 15.0.1+9-18)Java HotSpot(TM) 64-Bit Server VM (build 15.0.1+9, mixed mode, sharing)
Étape 5 : Écrire un programme Java Hello-World
  1. Créer un répertoire pour conserver vos travaux, par exemple, « d:\myProject » ou « c:\myProject« . N’enregistrez PAS vos travaux dans « Bureau » ou « Documents », car ils sont difficiles à localiser. Le nom du répertoire ne doit pas contenir de caractères blancs ou spéciaux. Utilisez un nom significatif mais court car il est plus facile à taper.
  2. Lancez un éditeur de texte de programmation (tel que TextPad, NotePad++, Sublime Text, Atom). Commencez par un nouveau fichier et entrez le code source suivant. Enregistrez le fichier sous le nom de « Hello.java« , sous votre répertoire de travail (par exemple, d:\myProject
    /* * First Java program to say Hello */public class Hello { // Save as "Hello.java" under "d:\myProject" public static void main(String args) { System.out.println("Hello, world!"); }}
Étape 6 : Compiler et exécuter le programme Java Hello-World

JavaBasics_GettingStarted.png

Pour compiler le code source « Hello.java« :

  1. Démarrer un shell CMD (Recherche ⇒ entrer « cmd » ⇒ sélectionner « Invite de commande »).
  2. Définir le lecteur actuel sur le lecteur où vous avez enregistré votre fichier source « Hello.java« .
    Si vous utilisez le lecteur « c », passez cette étape.
    Else si vous utilisez le lecteur « d« , entrez « d: » comme suit :
    d:D:\xxx>
  3. Régler le répertoire de travail actuel sur le répertoire dans lequel vous avez enregistré votre fichier source via la commande cd (Change Directory). Par exemple, supposons que votre fichier source est sauvegardé dans le répertoire « myProject« .
    cd \myProjectD:\myProject>
  4. Lancer une commande dir (List Directory) pour confirmer que votre fichier source est présent dans le répertoire actuel.

    dir......xx-xxx-xx xx:xx PM 277 Hello.java......
  5. Invoquer le compilateur JDK « javac » pour compiler le code source « Hello.java
    javac Hello.java// If error message appears, correct your source code and re-compile

    La compilation est réussie si l’invite de commande revient. Dans le cas contraire, des messages d’erreur s’afficheraient. Corrigez les erreurs dans votre fichier source et recompilez. Vérifiez « Erreurs d’installation communes du JDK », si vous rencontrez un problème pour compiler votre programme.

  6. La sortie de la compilation est une classe Java appelée « Hello.class« . Émettez à nouveau une commande dir (List Directory) pour vérifier la sortie.
    dir......xx-xxx-xx xx:xx PM 416 Hello.classxx-xxx-xx xx:xx PM 277 Hello.java......

Pour exécuter le programme, invoquez le Runtime Java « java« :

java HelloHello, world!

Tout ce qui peut mal tourner tourner tournera mal : Lisez « Erreurs courantes d’installation du JDK ».

Étape 7 : (pour les utilisateurs avancés uniquement) Le code source du JDK

Le code source du JDK est fourni et conservé dans « <JAVA_HOME>\lib\src.zip« . (ou « <JAVA_HOME>\src.zip » avant le JDK 9). Je vous recommande vivement de parcourir certains des fichiers sources tels que « String.javaMath.java« , et « Integer.java« , sous « java\lang« , pour apprendre à programmer les experts.

Comment installer JDK sur macOS

Étape 1 : Vérifier si JDK a été préinstallé

Pour vérifier si JDK a été installé, ouvrez un  » Terminal  » (Recherchez  » Terminal  » ; ou Finder ⇒ Go ⇒ Utilities ⇒ Terminal) et lancez cette commande :

javac -version
  • Si un numéro de version de JDK est renvoyé (par ex.g., JDK x.x.x), alors JDK a déjà été installé. Si la version de JDK est antérieure à 1.8, passez à l’étape 2 pour installer le dernier JDK ; sinon, passez à l' » Étape 3 : Écrire un programme Java Hello-world « .
  • Si le message  » command not found  » apparaît, JDK n’est PAS installé. Passez à l' »Étape 2 : Installer JDK ».
  • Si le message « Pour ouvrir javac, vous avez besoin d’un runtime Java » apparaît, sélectionnez « Installer » et suivez les instructions pour installer JDK. Ensuite, passez à « Étape 3 : Écrire un programme Java Hello-world ».
Étape 2 : Télécharger le JDK
  1. Voir le site de téléchargement du JDK (ou Java SE) @ https://www.oracle.com/java/technologies/javase-downloads.html.
  2. Sous « Oracle JDK », cliquez sur « JDK Download ».
  3. Téléchargez le « macOS DMG installer » (par exemple, jdk-15.0.{x}_osx-x64_bin.dmg – environ 172 Mo, où {x} est un numéro de mise à jour qui change rapidement).
Étape 3 : installer JDK/JRE
  1. Double-cliquez sur le fichier image disque (DMG) téléchargé. Suivez les instructions à l’écran pour installer JDK/JRE.
  2. Ejectez le fichier DMG.
  3. Pour vérifier votre installation, ouvrez un « Terminal » et émettez ces commandes.
    // Display the JDK versionjavac -versionjavac 15.0.{x} // Display the JRE versionjava -versionjava version "15.0.{x}"...... // Display the location of Java Compilerwhich javac/usr/bin/javac // Display the location of Java Runtimewhich java/usr/bin/java
Étape 3 : Écrire un programme Java Hello-World
  1. Créer un répertoire appelé « myProject » sous votre répertoire « home » (Lancez « Finder » ⇒ « Go » ⇒ « Home » ; Sélectionnez « File » ⇒ « New Folder » ⇒ « myProject« ).
    Dans macOS/Unix, le répertoire « home » de l’utilisateur actuel peut être référencé comme « ~« . Par conséquent, ce nouveau répertoire peut être référencé comme « ~/myProject« .
  2. Utiliser un éditeur de texte de programmation (tel que Sublime Text ou Atom) pour saisir le code source suivant et l’enregistrer comme « Hello.java« sous le répertoire « ~/myProject« .
    (Si vous utilisez l’éditeur de texte par défaut de macOS « TextEdit » (NON recommandé), vous devez ouvrir un nouveau fichier ⇒ choisir « Format » ⇒ « Faire du texte brut » ⇒ Saisir le code source ⇒ Enregistrer sous « Hello.java
    /* * My First Java program to say Hello */public class Hello { // Save as "Hello.java" under "~/myProject" public static void main(String args) { System.out.println("Hello, world from Mac!"); }}

Étape 4 : Compiler et exécuter le programme Java Hello-World

MacJavaCompile.png

  1. Pour compiler le code source « Hello.java« , ouvrez un nouveau « Terminal » (« Go » ⇒ « Utilities » ⇒ « Terminal ») et lancez ces commandes (comme illustré) :
    // Change Directory (cd) to where "Hello.java" residescd ~/myProject // Check if "Hello.java" exists using list (ls) commandlsHello.java ...... // Compile "Hello.java" using JDK compiler "javac"javac Hello.java// If error message appears, correct your source code and re-compile // Check for the compiled output "Hello.class"lsHello.class Hello.java ......
  2. Pour exécuter le Hello-world, invoquez le Runtime Java « java » comme suit :
    java HelloHello, world from Mac!

Comment installer le JDK sur Ubuntu

Nous allons essayer à la fois l’OpenJDK (gratuit et open-source) et l’Oracle JDK (gratuit pour le personnel et le développement, mais pas gratuit pour la production).

Etape 0 : Vérifier si le JDK a déjà été installé

Ouvrir un Terminal et lancer cette commande :

$ javac -version

Si un numéro de version du JDK (par exemple , « javac x.x.x« ) apparaît, JDK a déjà été installé. Vous pouvez ignorer l’installation et passer à Open2.

Etape 1a : Installer OpenJDK

Pour supprimer OpenJDK, émettez la commande:

$ sudo apt-get purge openjdk-\*
Etape 1b : Installer le JDK d’Oracle
  1. Voir le site de téléchargement du JDK (Java SE) d’Oracle @ https://www.oracle.com/java/technologies/javase-downloads.html ⇒ Sous « Oracle JDK », cliquez sur « JDK Download » ⇒ Sélectionnez le paquet « Linux x64 Compressed Archive » (par ex, « jdk-15.0.{x}-linux-x64_bin.tar.gz » – 179MB).L’archive tarball sera téléchargée dans le répertoire « ~/Downloads« , par défaut.
  2. Nous allons installer JDK sous « /usr/local/java » (ou le répertoire JDK par défaut d’Ubuntu /usr/lib/jvm ; ou /opt/java). Tout d’abord, créez un répertoire « java » sous « /usr/local« . Ouvrez un terminal et lancez les commandes suivantes :
    $ cd /usr/local$ sudo mkdir java

    Extraire le paquet téléchargé (Vérifiez le nom de votre fichier téléchargé !)

    $ cd /usr/local/java$ sudo tar xzvf ~/Downloads/jdk-15.0.{x}-linux-x64_bin.tar.gz // x: extract, z: for unzipping gz, v: verbose, f: filename

    JDK doit être extrait dans un dossier « /usr/local/java/jdk-15.0.{x}« , où {x} est le numéro de mise à jour.

  3. Informer l’Ubuntu d’utiliser ce JDK/JRE :
    // Setup the location of java, javac and jshell via the "alternatives" system$ sudo update-alternatives --install "/usr/bin/java" "java" "/usr/local/java/jdk-15.0.{x}/bin/java" 1 // --install symlink name path priority$ sudo update-alternatives --install "/usr/bin/javac" "javac" "/usr/local/java/jdk-15.0.{x}/bin/javac" 1$ sudo update-alternatives --install "/usr/bin/jshell" "java/usr/local/java/jdk-15.0.{x}/bin/jshell" 1 // Use this Oracle JDK/JRE as the default$ sudo update-alternatives --set java /usr/local/java/jdk-15.0.{x}/bin/java // --set name path$ sudo update-alternatives --set javac /usr/local/java/jdk-15.0.{x}/bin/javac$ sudo update-alternatives --set jshell /usr/local/java/jdk-15.0.{x}/bin/jshell

    Les étapes ci-dessus mettent en place des liens symboliques javajavacjshell/usr/bin (qui se trouve dans le PATH), qui renvoient vers /etc/alternatives puis vers le répertoire bin du JDK.
    Le système des « alternatives » vise à résoudre la situation où plusieurs programmes remplissant la même fonction (ex, différentes versions de JDKs). Il met en place des liens symboliques à travers /etc/alternatives pour faire référence aux programmes réels à utiliser.

    $ ls -ld /usr/bin/java*lrwxrwxrwx 1 root root xx xxx xx xx:xx /usr/bin/java -> /etc/alternatives/java...... $ ls -ld /etc/alternatives/java*lrwxrwxrwx 1 root root xx xxx xx xx:xx /etc/alternatives/java -> /usr/local/java/jdk-15.0.{x}/bin/java......// As the resultjava -> /usr/bin/java (thru PATH) -> /etc/alternatives/java -> /usr/local/java/jdk-15.0.{x}/bin/java (actual program)

    Alternativement, vous pouvez inclure directement le bin du JDK dans le PATH.

  4. Pour vérifier l’installation du JDK, lancez ces commandes:
    // Show the Java Compiler (javac) version$ javac -versionjavac 15.0.{x} // Show the Java Runtime (java) version$ java -versionjava version "15.0.{x}"...... // Show the location of javac and java$ which javac/usr/bin/javac$ which java/usr/bin/java
  5. (Ne faites pas cette étape – Elle est prise en charge par les « alternatives » à l’étape 3. Gardez ici pour vous montrer comment définir le PATH.)
    Ajouter le répertoire binaire de JDK (« bin« ) au « PATH » en éditant « /etc/profile
    $ cd /etc$ sudo nano profile

    Ajouter ces lignes à la fin du fichier « /etc/profile« , remplacer « {x} » par le numéro réel:

    export JAVA_HOME=/usr/local/java/jdk-15.0.{x}export PATH=$JAVA_HOME/bin:$PATH

    Relancer le fichier de configuration par :

    // Refresh$ source /etc/profile // Check the new settings for JAVA_HOME and PATH$ echo $JAVA_HOME/usr/local/java/jdk-15.0.{x} $ echo $PATH/usr/local/java/jdk-15.0.{x}/bin:......

Étape 2 : Compiler et exécuter un programme Java Hello-world
  1. Explorateur de fichiers ⇒ Accueil ⇒ Créer un nouveau dossier appelé « myProject » pour conserver nos travaux.
  2. Ouvrez « l’éditeur de texte » (gedit). Saisissez le code source suivant et enregistrez-le sous « Hello.java » sous le répertoire « ~/myProject » créé précédemment.
    public class Hello { // To save as "Hello.java" under "~/myProject" public static void main(String args) { System.out.println("Hello, world from Ubuntu!"); }}
  3. Pour compiler le programme Java Hello-world, lancez un Terminal et émettez ces commandes :
    // Change directory to where the source code resides$ cd ~/myProject // List the contents of current directory. Check for "Hello.java"$ ls...... Hello.java ...... // Compile "Hello.java" into "Hello.class"$ javac Hello.java // Check for "Hello.class"$ ls...... Hello.class ......
  4. Exécuter le programme Java Hello-world :
    // Run "Hello.class"$ java HelloHello, world from Ubuntu!

Notes : À partir du JDK 11, vous pouvez compiler et exécuter le programme hello-world en une seule étape via :

// Compile and Run "Hello.java" in one step without creating the ".class"$ java Hello.javaHello, world from Ubuntu!

Éditeurs de code source & IDE pour la programmation Java

Eclipse IDE

  1. Vous devez d’abord installer Eclipse. Lisez « Comment installer Eclipse ».et >
  2. javaan puis procéder à l’écriture de votre premier programme Java. Lisez « Écrire votre premier programme Java avec Eclipse ».
  3. Eclipse vous permet de déboguer le programme graphiquement. Lisez « Déboguer un programme dans Eclipse ».

L’IDE NetBeans

  1. Vous devez d’abord installer NetBeans. Lisez « Comment installer NetBeans ».
  2. Vous pouvez ensuite procéder à l’écriture de votre premier programme Java. Lisez « Écrire votre premier programme Java avec NetBeans ».
  3. NetBeans vous permet de déboguer le programme graphiquement. Lisez « Déboguer un programme dans NetBeans ».

Visual Studio (VS) Code IDE

Cliquez ICI, cherchez « VS Code pour la programmation Java »

Sublime Text (pour Windows, macOS, Linux)

Cliquez ICI, recherchez « Sublime Text pour la programmation Java »

Atom (pour Windows, macOS, Linux)

TextPad (pour Windows uniquement)

Cliquez ICI, recherchez « TextPad pour la programmation Java ».

NotePad++ (pour Windows uniquement)

Cliquez ICI, recherchez « NotePad++ pour la programmation Java ».

(Nouvelle fonctionnalité du JDK 11) Lancer un fichier mono-source

Depuis le JDK 11, vous pouvez « compiler et exécuter » un programme mono-fichier en une seule étape, sans compilation explicite.

  1. Écrire un « Hello.java« . (voir section précédente).
  2. Supprimez « Hello.class« , si elle existe.
  3. Vous pouvez compiler/exécuter « Hello.java » en une seule commande comme suit :
    // Change directory to the directory containing Hello.java// Compile and Run in ONE commandjava Hello.javaHello, world!

Notes:

  • Cela ne s’applique qu’à un seul fichier source.
  • Nul besoin d’utiliser javac pour compiler le programme.
  • Il se compile en mémoire (sans produire de .class fichier), et s’exécute.
  • Cette fonctionnalité est introduite pour les débutants pour apprendre Java, et pour les professionnels pour tester une fonctionnalité Java.
  • Le nom de fichier et le nom de classe ne doivent pas nécessairement être les mêmes.

Comment définir la variable d’environnement JAVA_HOME

Plusieurs applications Java (telles que Tomcat) nécessitent que la variable d’environnement JAVA_HOME soit définie sur le répertoire installé du JDK.

Voir « Comment définir JAVA_HOME pour Windows » ou « Comment définir JAVA_HOME pour macOS/Linux ».

Erreurs courantes lors de l’installation de JDK

SYMPTOM: Cannot compile Java program from the CMD shell (e.g., "javac Hello.java" does not work!)ERROR MESSAGE: 'javac' is not recognized as an internal or external command, operable program or batch file.PROBABLE CAUSES: The PATH environment variable, which maintains a list of search paths for executable programs (including "javac.exe"), does not include JDK's bin directory.POSSIBLE SOLUTIONS: 1) Start a CMD shell (click "Start" button ⇒ "run..." ⇒ enter "cmd") and issue a path command: prompt> path PATH=....... 2) Check if it includes your JDK's "bin" directory. For example, suppose that your JDK is installed in "c:\program files\java\jdk-15.0.1", then PATH should include "c:\program files\java\jdk-15.0.1\bin". Otherwise, include JDK's bin directory in the PATH environment variable. Read "Step 3 of How to install JDK".

SYMPTOM: Can compile but cannot run Java program from the CMD shell (e.g., "java Hello" does not work!)ERROR MESSAGE (Post JDK 1.7): Error: Could not find or load main class XxxERROR MESSAGE (Pre JDK 1.7): Exception in thread "main" java.lang.NoClassDefFoundError: XxxPROBABLE CAUSES: 1) The Java class (in this example, Hello.class) is NOT in the current directory. 2) The CLASSPATH environment variable is set, but does not include the current directory ".".POSSIBLE SOLUTIONS: 1) Issue a "dir" command to list the contents of the current directory. Check that it contains the Java class to be run (e.g., Hello.class). You need to compile the source program (".java") to get the class file (".class"). 2) If the Java class is present in the current directory, issue a "set classpath" command to check its settings: prompt> set classpath CLASSPATH=....... If you receive the message "Environment variable CLASSPATH not defined" and your program is correct, I can't help you here. Otherwise, if the CLASSPATH is defined, for beginner, I suggest that you remove the CLASSPATH environment variable. From "Control Panel" ⇒ System ⇒ (Vista only) Advanced system settings ⇒ Switch to "Advanced" tab ⇒ Environment Variables ⇒ System variables (and also User variables) ⇒ Select variable "CLASSPATH" ⇒ Delete (Delete from both the System variables and User variables) 3) (For Advanced Users Only) If CLASSPATH is not set, it is defaulted to the current directory. However, if CLASSPATH is set, the current directory is NOT implicitly included. You can include the current directory (denoted by a single dot ".") in front of the existing class-paths. Read "Java Applications and Environment Variable" for more discussion on CLASSPATH.

SYMPTOM: Can compile but cannot run the Hello-world program (e.g., "java Hello" does not work!)ERROR MESSAGE (Post JDK 1.7): Error: Main method not found in class Hello.POSSIBLE SOLUTIONS: Check whether there is a main() method in your program, and the signature of your main() as shown in the error message.

(Advanced) External JAR Files and Native Libraries

Notes : Cette section est applicable aux JDK antérieurs au JDK 9. Le JDK 9 introduit un nouveau niveau appelé « module » au-dessus du package, et des fichiers « jmod » pour les modules Java. Il faut réviser cette section pour le JDK 9.

Les paquets d’API Java externes (tels que Servlet API, MySQL Connector/J, JOGL, JUnit) sont souvent distribués dans des fichiers JAR (Java Archive – un paquet à fichier unique de nombreuses classes Java similaire à ZIP ou TAR), avec éventuellement des bibliothèques natives (« .lib » et « .dll » sous Windows, ou « .a » et « .so » sous Linux/macOS).

Fichiers JAR externes (« .jar »)

Si les fichiers JAR externes ne sont pas correctement inclus :

  • Pendant la compilation, vous recevrez l’erreur de compilation « cannot find symbol » pour les classes appartenant aux packages externes.
  • Pendant l’exécution, vous recevrez une erreur d’exécution « Could not find or load main class xxx » ou « NoClassDefFoundError« .

Pour inclure les fichiers JAR externes, vous pouvez soit :

  1. (Avant le JDK 9) Copier tous les fichiers JAR des paquets externes dans les répertoires d’extension de Java (NON applicable à partir du JDK 9).
    • Pour Windows, le répertoire d’extension du JDK est situé à « <JAVA_HOME>\jre\lib\ext« . (par exemple , « c:\Program Files\Java\jdk1.8.0_xx\jre\lib\ext« ).
    • Pour macOS, les répertoires d’extension JDK sont « /Library/Java/Extensions » et « /System/Library/Java/Extensions« .
    • Pour Ubuntu, les répertoires d’extension du JDK sont « <JAVA_HOME>/jre/lib/ext« . (par exemple, « /usr/user/java/jdk1.8.0_xx/jre/lib/ext« ) et « /usr/java/packages/lib/ext« .

    L’emplacement des répertoires d’extension du JDK est conservé dans la propriété système de Java « java.ext.dirs« . Vous pouvez imprimer son contenu via System.out.println(System.getProperty("java.ext.dirs")).

  2. Vous pouvez également inclure tous les fichiers JAR dans la variable d’environnement CLASSPATHCLASSPATH peut contenir des répertoires (de classes Java) ou des fichiers JAR (archive à fichier unique de classes Java). Si vous définissez la CLASSPATH, vous devez également inclure le répertoire actuel (désigné par « .« ).
    • Pour Windows, définissez la CLASSPATH dans Panneau de configuration ⇒ Système ⇒ Paramètres système avancés ⇒ Avancé ⇒ Variables d’environnement ⇒ Variables système ⇒ Nouveau ⇒ Dans « Nom de la variable », entrez « CLASSPATH« . ⇒ Dans « Valeur de la variable », entrez « .;path1\xxx.jar;path2\yyy.jar« , où les entrées sont séparées par un point-virgule (;).
    • Pour Linux et macOS : modifiez ~/.profile ou ~/.bash_profile (ou /etc/profile pour un réglage à l’échelle du système) pour inclure la ligne suivante à la fin du fichier :
      export CLASSPATH=.:path1/xxx.jar:path2/yyy.jar

      Les entrées sont séparées par des deux-points (:).

  3. Vous pouvez également définir la CLASSPATH dans la javacjava ligne de commande.via l’option -cp <paths> (ou -classpath <paths>), par exemple,
    // For Windows// Compile Java source codejavac -cp .;path1\xxx.jar;path2\yyy.jar ClassName.java// Run Java classjava -cp .;path1\xxx.jar;path2\yyy.jar ClassName // For macOS and Ubuntu// Compile Java source codejavac -cp .:path1/xxx.jar:path2/yyy.jar ClassName.java// Run Java classjava -cp .:path1/xxx.jar:path2/yyy.jar ClassName
Les bibliothèques natives externes (« .lib », « .dll », « .a », « .so »)

Certains paquets externes peuvent fournir des bibliothèques natives statiques ou partagées sous la forme de « .lib« . (bibliothèque statique de Windows), « .dll » (bibliothèque à liaison dynamique de Windows), « .a » (bibliothèque statique (archive) d’Unix) ou « .so« . (bibliothèque d’objets partagés d’Unix).

Les bibliothèques natives doivent être conservées dans un répertoire accessible via la propriété de JRE « java.library.path« , qui inclut normalement mais pas nécessairement tous les répertoires de la variable d’environnement PATH.

Les bibliothèques natives n’interviennent pas dans la compilation. Mais si elles ne sont pas correctement incluses au moment de l’exécution, vous obtiendrez une erreur d’exécution « java.lang.UnsatisfiedLinkError: no xxx in java.library.path« .

Pour inclure des bibliothèques natives externes :

  1. Copier les bibliothèques natives dans un répertoire de bibliothèques système, par exemple, c:\windows\system32 (Windows), /usr/lib ou /usr/local/lib (macOS/Unix). Vous pouvez vérifier que le répertoire est inclus dans la propriété système de Java « java.library.path« , via System.out.println(System.getProperty("java.library.path")).
  2. Vous pouvez également définir le chemin de la bibliothèque native via l’option de ligne de commande java de -Djava.library.path=xxx, par exemple,
    // Run a Java programjava -Djava.library.path=xxx ClassName
Eclipse/NetBeans

L’utilisation d’un IDE peut grandement simplifier l’inclusion de paquets externes. Lisez « Eclipse How-To » ou « NetBeans How-To ».

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *