Aller au contenu

JOUR 2 – COMPRENDRE UN PROJET JAVA, L’IDE, LES PACKAGES ET LA CHAÎNE DE BUILD

Formation Java / Spring Boot pour développeurs COBOL

illustration du cours

Objectifs pédagogiques

À l’issue de cette journée, vous serez capable de :

Cette journée vise à maitriser l’IDE : vous devez comprendre ce qui se passe réellement et vous familiariser avec l’interface de l’IDE Eclipse.

Rappel : Mise en contexte (COBOL → Java)

En COBOL (mainframe), vous avez une chaîne de traitement assez stable :

En Java, la notion de projet inclut plus d’éléments :

Java est un langage qui nécessite de la rigueur comme en Cobol !

Projet et classe

Avant de poursuivre, notre JDK est installé, ainsi que Java version 17 et notre outil pour développer (Eclipse)

Sinon retour vers cette page

1) Qu’est-ce qu’un projet Java ?

Un projet Java, c’est :

  1. Une organisation standard de fichiers (dossiers)
  2. Des conventions de nommage (packages, classes, méthodes, variables)
  3. Un mécanisme de compilation (javac.exe)
  4. Un mécanisme d’exécution (java.exe)
  5. Éventuellement : une gestion de dépendances (Maven/Gradle par la suite)
  6. Bibliothèques (API)

2) Fichier .java, .class et package

2.1 Une classe Java = une unité de code

Exemple :

2.2 Un fichier .java peut contenir plusieurs classes (mais on évite)

Règle pratique :

Donc, en réalité, on peut avoir plusieurs classes dans un fichier mais une seule est de type public, c’est celle qui correspond au nom du fichier java.

3) Les packages : pourquoi c’est indispensable ?

Voici des explications approfondies sur l’utilisation des packages et du fichier package-info.java lors de la généréation de la documentation.

Un package sert à :

Comparaison COBOL :

Exemple de classement typique (pour le futur avec Spring Boot) :

Importations de classe (Import)

Selon nos besoins, nous allons importer certaines classes dans nos fichiers Java. Il faudra toujours vérifier que vous importez la bonne classe !

Exemple avec la notion de package : Nous avons 2 packages contenant chacun une classe avec le même nom Message

Pour simplifier, j’ai déclaré une méthode static pour ne pas instancier d’objet (pas d’inquiétude, nous verrons ces notions prochainement)

Structure du projet avec 2 packages fr.formation.app.v1 et fr.formation.app.v2 contenant chacun une classe avec le même nom : Message.java

notion de package

Ici, on utilise la classe du package v1 :

notion de package

Ici, on utilise la classe du package v2 :

notion de package

Notion de PID et exécution avec javaw.exe (Eclipse)

Pour comprendre à quoi cela correspond, j’ai rédigé une note complémentaire…

4) Arborescence standard d’un projet Java (avec Maven)

Même si vous n’utilisez pas Maven immédiatement, cette structure est devenue une norme de fait :

banque/
├─ pom.xml
└─ src/
├─ main/
│ ├─ java/
│ │ └─ com/banque/app/...
│ └─ resources/
└─ test/
   ├─ java/
└─ resources/

Comparaison COBOL :

5) Compilation et exécution : ce que l’IDE fait pour vous

5.1 Compilation manuelle (révision du Jour 1)

Compilation (si on est dans le répertoire du fichier .java):

javac HelloBanque.java

5.2 Avec des packages

Si votre classe se trouve dans un package :

package com.banque.app;

public class HelloBanque {
    public static void main(String[] args) {
        System.out.println("Encore un message qui ne sert à rien !");
    }
}

Le fichier doit être placé dans un dossier correspondant au package :

src/main/java/com/banque/app/HelloBanque.java

La compilation doit produire un .class au bon endroit (bin ou target selon la configuration du projet).

6) Le classpath : pourquoi Java ne trouve pas toujours vos classes ?

Quand vous exécutez java, la JVM cherche les classes dans un ensemble d’emplacements : classpath

Si le classpath est mal configuré, vous allez avoir :

L’IDE règle le classpath automatiquement, mais vous devez comprendre où se trouvent vos .class et à partir de quel répertoire la JVM les cherche.

7) L’IDE : ce qu’il fait réellement (vous le savez déjà ;)

Mais l’IDE n’est pas Java, ce n’est que votre assistant qui :

Introduction progressive à Maven (optionnelle)

Maven sert à :

Le fichier central est pom.xml

Vous n’avez pas besoin de Maven aujourd’hui. Vous devez seulement comprendre que Maven remplace une compilation à la main par une compilation standard.

On peut utiliser des commandes utiles (on les utilisera par la suite dans la partie DevOps de la formation) :

mvn -v
mvn compile
mvn test
mvn package

Comparaison COBOL ↔ Java

1) Organisation et noms

COBOL Java Explication
PROGRAM-ID Nom de classe L’unité exécutable en Java est une classe avec main (au début)
Bibliothèque / environnement Projet Un projet inclut structure, config et dépendances
Copybook Dépendance / classe utilitaire Plus tard : dépendances Maven / code partagé

2) Chaîne de traitement

COBOL Java
Compile + link Compile .java → .class (pas de link classique)
Exécutable/module Bytecode .class ou package .jar
JCL / jobs Scripts Maven/Gradle, exécution outillée

Démonstrations guidées (pas à pas)

Démo 1 – Créer un projet Java et ajouter un package

Étape 1 : créer un projet (IDE)

Creation projet Java

ProjetAvecWorkingSet

ProjetAvecWorkingSet

Étape 2 : Créer un package

ProjetAvecWorkingSet

ProjetAvecWorkingSet

Étape 3 : Créer la classe PauseCafe (ou autre)

ProjetAvecWorkingSet

ProjetAvecWorkingSet

Voici le code à mettre dans la méthode main de votre classe :

System.out.println("Enfin, le moment de prendre un petit café :)");

ProjetAvecWorkingSet

Étape 4 : exécuter depuis votre IDE

ProjetAvecWorkingSet

Observez :

ProjetAvecWorkingSet

Ce que vous devez retenir : l’IDE compile et exécute pour vous, mais vous devez savoir ce qu’il fait.

Démo 2 – Comprendre la notion de package et dossier

Pour vous entrainer dans le processus, refaites les étapes précédentes en créant un autre projet, un package et une classe avec une méthode main().

Vous créez votre package com.banque.app et votre fichier java PauseDejeuner.java

Exécutez !

Avez-vous placer le fichier au bon endroit dans le bon package : src/com/banque/app/PauseDejeuner.java ?

Démo 3 – Exécuter en ligne de commande avec package puis avec l’IDE

Objectif : comprendre le classpath et les dossiers.

Supposons l’arborescence ci-dessous (noter que selon la configuration de l’IDE, main/java/ n’est pas présent):

banque-jour2/
└─ src/
   └─ com/
      └─ banque/
         └─ app/
            └─ PauseDejeuner.java
      └─ autre/

Vous trouverez souvent cette configuration avec des projets Maven :

banque-jour2/
└─ src/
   └─ main/
      └─ java/
         └─ com/
            └─ banque/
               └─ app/
                  └─ PauseDejeuner.java
            └─ autre/

Compilation dans le Terminal (en sortant les .class dans un dossier out)

Depuis la racine de votre projet :

mkdir out
javac -d out src/com/banque/app/PauseDejeuner.java

Explication : -d out signifie : Mettre les .class dans le dossier out en respectant les packages.

Vous obtenez : out/com/banque/app/PauseDejeuner.class. On pourrait remplace out par bin. Nous verrons qu’avec Maven, le répertoire de compilation se nomme target !

Exemple d’exécution (en indiquant le classpath) :

java -cp out com.banque.app.PauseDejeuner

Explication :

-cp out : indique que la JVM doit chercher les classes dans out

La syntaxe est toujours celle-ci com.banque.app.PauseDejeuner : nom complet de la classe (package + nom). C’est comme si on indiquait un chemin pour arriver jusqu’à la classe.

Diagnostiquer et corriger 3 erreurs classiques

Objectif : apprendre à lire les erreurs Java et corriger sans paniquer.

Erreur A : nom de fichier / nom de classe / package absent

Voici un code que vous allez mettre dans votre package, un fichier java que vous nommerez message mais sans mettre le package en début de programme.

public class Messages {

    //public static void main(String[] args) {
    System.out.println("Je veux voir mon message dans la console");
    //}
}

Evidemment, Eclipse va vous insulter tandis que via NotePad++, vous allez sauvegarder, compiler… enfin tenter de compiler ;)

voici ce que cela donne dans Eclipse :

erreur 1

erreur 2

Selon vous, pourquoi ? quels sont les problèmes ?

Observez les erreurs et corrigez !

Classe corrigée :

classe corrigée

Découverte de Args (arguments de lancement)

Objectif : comprendre la String[] args de la méthode main()

Consigne : Afficher le nombre d’arguments (chaque argument avec son index)

Exemple attendu :

Nombre d'arguments : 3
0 -> CA
1 -> 2026
2 -> PROD

Comme vous débutez, voici le code de la classe :

package com.banque.app;

public class ArgsDemo {
    public static void main(String[] args) {

        System.out.println("Nombre d'arguments : " + args.length);

        for (int i = 0; i < args.length; i++) {

            System.out.println(i + " -> " + args[i]);
        }
    }
}

Exécution en ligne de commande (dans le Terminal) :

javac -d out src/main/java/com/banque/app/ArgsDemo.java
java -cp out com.banque.app.ArgsDemo CA 2026 PROD

Version avec Eclipse

Choisir Run Configurations… :

classe corrigée

Choisir la classe qui contient le Main dans le bon package :

classe corrigée

Ajout des arguments :

classe corrigée

Affichage dans la console :

classe corrigée

Synthèse de la journée

Vous savez maintenant :

C’est la base absolue avant d’écrire du code Java sérieux.

Conclusion

Le jour 3, nous passons aux choses sérieuses (enfin, un peu plus sérieuses)

On abodera :