Aller au contenu principal

Module Java.2 – Environnement

Objectif​

Configurer l'environnement de développement Java : installer JDK, comprendre la structure d'un projet, maîtriser les packages, et utiliser les outils de développement.

Théorie​

JDK (Java Development Kit)​

Le JDK contient tous les outils nécessaires pour développer en Java.

Composants du JDK​

1. Compilateur (javac)

  • Compile le code source .java en bytecode .class
  • Vérifie la syntaxe et les types
  • Génère les fichiers .class

2. JVM (java)

  • Exécute les applications Java
  • Charge et interprète le bytecode
  • Gère la mémoire et le garbage collector

3. Outils de développement

  • jar : Crée des archives JAR
  • javadoc : Génère la documentation
  • jdb : Débogueur Java
  • javap : Désassembleur de bytecode
  • jconsole : Monitoring de la JVM

4. Bibliothèques

  • Java Standard Library (java.lang, java.util, etc.)
  • API Java complète

Installation​

Windows :

  1. Télécharger depuis oracle.com ou adoptium.net
  2. Exécuter l'installateur
  3. Configurer JAVA_HOME (optionnel mais recommandé)

macOS :

# Via Homebrew
brew install openjdk@17

# Ou télécharger depuis oracle.com

Linux :

# Ubuntu/Debian
sudo apt update
sudo apt install openjdk-17-jdk

# Ou via gestionnaire de paquets

Vérification :

java -version
javac -version

Configuration JAVA_HOME :

# Windows
set JAVA_HOME=C:\Program Files\Java\jdk-17

# macOS/Linux
export JAVA_HOME=/usr/lib/jvm/java-17-openjdk

Structure d'un projet​

Structure de base​

MonProjet/
├── src/                    # Code source
│   └── com/
│       └── monprojet/
│           ├── Main.java
│           ├── models/
│           │   └── Personne.java
│           └── utils/
│               └── Utils.java
├── bin/                    # Fichiers compilés (.class)
└── README.md

Structure Maven (standard)​

mon-projet/
├── src/
│   ├── main/
│   │   ├── java/          # Code source
│   │   │   └── com/monprojet/
│   │   └── resources/     # Ressources (config, etc.)
│   └── test/
│       └── java/          # Tests
├── pom.xml                # Configuration Maven
└── target/                # Fichiers générés

Structure Gradle​

mon-projet/
├── src/
│   ├── main/java/
│   └── test/java/
├── build.gradle           # Configuration Gradle
└── build/                 # Fichiers générés

Packages​

Les packages organisent le code en namespaces.

Déclaration​

package com.monprojet;

public class Main {
    public static void main(String[] args) {
        System.out.println("Bonjour");
    }
}

Convention de nommage​

Structure inversée du domaine :

  • com.monprojet : Pour com.monprojet
  • org.apache : Pour org.apache
  • edu.universite : Pour université

Exemples :

package com.monprojet.models;
package com.monprojet.controllers;
package com.monprojet.utils;

Compilation avec packages​

Structure :

src/
└── com/
    └── monprojet/
        └── Main.java

Compilation :

# Depuis le dossier src
javac -d ../bin com/monprojet/Main.java

# Ou depuis la racine
javac -d bin src/com/monprojet/Main.java

Exécution :

# Depuis la racine
java -cp bin com.monprojet.Main

Import​

package com.monprojet;

// Import d'une classe
import java.util.ArrayList;
import java.util.List;

// Import de tout le package
import java.util.*;

// Import statique (méthodes statiques)
import static java.lang.Math.PI;
import static java.lang.Math.sqrt;

public class Main {
    public static void main(String[] args) {
        List<String> liste = new ArrayList<>();
        double resultat = sqrt(4) * PI;
    }
}

CLASSPATH​

Le CLASSPATH indique où chercher les classes.

Définition :

  • Liste de répertoires ou fichiers JAR
  • Séparés par : (Linux/macOS) ou ; (Windows)

Utilisation :

# Via option -cp
java -cp "bin:lib/*" com.monprojet.Main

# Via variable d'environnement
export CLASSPATH=bin:lib/*
java com.monprojet.Main

Outils de développement​

javac (Compilateur)​

# Compiler un fichier
javac MonFichier.java

# Compiler avec encodage
javac -encoding UTF-8 MonFichier.java

# Compiler avec classpath
javac -cp lib/*.jar MonFichier.java

# Compiler plusieurs fichiers
javac *.java

# Compiler avec packages
javac -d bin src/com/monprojet/*.java

java (Exécuteur)​

# Exécuter une classe
java MaClasse

# Avec classpath
java -cp bin:lib/* com.monprojet.Main

# Avec options JVM
java -Xmx512m -Xms256m MaClasse

# Avec arguments
java MaClasse arg1 arg2 arg3

jar (Archivage)​

# Créer un JAR
jar cvf monprojet.jar -C bin .

# Créer un JAR exécutable
jar cvfe monprojet.jar com.monprojet.Main -C bin .

# Extraire un JAR
jar xvf monprojet.jar

# Lister le contenu
jar tf monprojet.jar

javadoc (Documentation)​

/**
 * Classe représentant une personne
 * 
 * @author Jean Dupont
 * @version 1.0
 */
public class Personne {
    /**
     * Nom de la personne
     */
    private String nom;
    
    /**
     * Constructeur
     * @param nom Le nom de la personne
     */
    public Personne(String nom) {
        this.nom = nom;
    }
    
    /**
     * Obtient le nom
     * @return Le nom de la personne
     */
    public String getNom() {
        return nom;
    }
}

Génération :

javadoc -d docs src/com/monprojet/*.java

IDE recommandés​

IntelliJ IDEA​

Avantages :

  • Excellent autocomplétion
  • Refactoring puissant
  • Intégration Maven/Gradle
  • Débogueur avancé

Versions :

  • Community Edition : Gratuite
  • Ultimate : Payante (essai gratuit)

Eclipse​

Avantages :

  • Gratuit et open source
  • Extensible via plugins
  • Support Maven/Gradle
  • Grande communauté

VS Code​

Avantages :

  • Léger et rapide
  • Extensions Java disponibles
  • Gratuit
  • Multi-langages

Extensions nécessaires :

  • Extension Pack for Java (Microsoft)
  • Maven for Java
  • Gradle for Java

Exercice​

  1. Installation JDK

    • Installez JDK sur votre système
    • Vérifiez java et javac
    • Configurez JAVA_HOME

  2. Structure de projet

    • Créez un projet avec structure organisée
    • Utilisez des packages
    • Organisez par fonctionnalité

  3. Compilation

    • Compilez avec javac
    • Testez différentes options
    • Comprenez les messages d'erreur

  4. Packages

    • Créez plusieurs packages
    • Utilisez import
    • Testez la compilation avec packages

  5. Outils

    • Testez jar pour créer une archive
    • Générez de la documentation avec javadoc
    • Explorez les options de java

Quiz​

  1. Que contient le JDK ?

    • Seulement le compilateur
    • Compilateur, JVM, outils, bibliothèques
    • Seulement la JVM

  2. Quelle est la convention pour les packages ?

    • Nom du projet
    • Domaine inversé (com.monprojet)
    • Nom aléatoire

  3. Que fait -cp dans java ?

    • Compile le code
    • Définit le classpath
    • Débogue le programme

  4. Comment compiler avec packages ?

    • javac Main.java
    • javac -d bin src/com/monprojet/*.java
    • javac Main

  5. Que fait javadoc ?

    • Compile le code
    • Génère la documentation
    • Exécute le programme

Mini défi​

Mission : Configurer un environnement Java professionnel

  1. Installation complète

    • Installez JDK (version LTS recommandée)
    • Configurez JAVA_HOME
    • Vérifiez tous les outils (javac, java, jar, javadoc)

  2. Structure de projet

    • Créez un projet "MonProjetJava"
    • Structurez avec packages (com.monprojet.models, utils, etc.)
    • Créez plusieurs classes dans différents packages

  3. Compilation et exécution

    • Compilez avec javac et options appropriées
    • Exécutez avec java et classpath
    • Testez avec des arguments

  4. Documentation

    • Ajoutez des commentaires javadoc
    • Générez la documentation
    • Vérifiez le résultat

  5. IDE

    • Installez IntelliJ IDEA ou Eclipse
    • Créez un projet dans l'IDE
    • Testez la compilation et l'exécution depuis l'IDE

Objectif : Avoir un environnement Java complet et professionnel, maîtriser la structure de projet et les outils.

Validation : Vous pouvez passer au module suivant quand vous avez un environnement Java configuré et pouvez créer/exécuter des projets avec packages.