Guide pratique · 3 parties · Projet fil rouge

Java,
démarrage express.

Retrouvez vos réflexes de Python et C#, adoptez la syntaxe Java, puis construisez pas à pas une application console de gestion des employés.

POUR

Étudiants de deuxième année ayant déjà pratiqué les variables, conditions, boucles, tableaux et fonctions.

Commencer la partie 1 Comment utiliser ce guide

Mode d’emploi

Lire peu. Tester beaucoup.

1

Lire le repère

La syntaxe utile tient en quelques lignes, avec les pièges propres à Java.

2

Chercher seul

Écrivez une première solution avant d’ouvrir la correction.

3

Révéler & comparer

Affichez la solution, copiez-la et testez-la sur votre ordinateur.

FichierMain.java
Compilerjavac Main.java
Exécuterjava Main
PARTIE01

Du premier fichier aux décisions

Écrire, saisir, calculer

On ne réapprend pas l’algorithmique : on traduit les réflexes déjà acquis vers la syntaxe Java.

Objectif

Saisir un employé, afficher sa fiche et appliquer des règles simples.

Le squelette

Un fichier, une classe, un point d’entrée

Le nom du fichier doit correspondre au nom de la classe publique. L’exécution commence dans main.

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

Le type est explicite

int age = 24;double salaire = 7800.50;String nom = "Amrani";boolean actif = true;

À retenir : String commence par une majuscule et les décimaux utilisent un point.

Affichage

Concaténer ou formater

System.out.println("Nom : " + nom);System.out.printf("Salaire : %.2f DH%n", salaire);

Repère : %n ajoute un retour à la ligne, %.2f affiche deux décimales.

Saisie clavier

Scanner lit les valeurs saisies

Extrait
import java.util.Scanner;

Scanner clavier = new Scanner(System.in);
System.out.print("Nom : ");
String nom = clavier.nextLine();
System.out.print("Âge : ");
int age = clavier.nextInt();

Piège fréquent : après nextInt() ou nextDouble(), appelez une fois nextLine() avant de relire du texte.

BesoinPythonC#Java
Conditionif age >= 18:if (age >= 18)if (age >= 18)
Boucle bornéefor i in range(5):for (int i=0; i<5; i++)for (int i=0; i<5; i++)
Égalité textenom == "Ali"nom == "Ali"nom.equals("Ali")
EX 01Prise en main

Afficher la fiche d’un employé

Déclarez les informations suivantes : code E101, nom El Amrani, prénom Salma, âge 27, salaire 8 500 DH et département Informatique. Affichez une fiche lisible.

Résultat attenduE101 — Salma El Amrani | 27 ans | Informatique | 8500.00 DH
Voir la solutionEssayez d’abord seul
Main.java
public class Main {
    public static void main(String[] args) {
        String code = "E101";
        String nom = "El Amrani";
        String prenom = "Salma";
        int age = 27;
        double salaire = 8500.0;
        String departement = "Informatique";

        System.out.printf(
            "%s — %s %s | %d ans | %s | %.2f DH%n",
            code, prenom, nom, age, departement, salaire
        );
    }
}

Pourquoi ? Chaque valeur possède un type. printf évite une longue concaténation et contrôle l’affichage du salaire.

EX 02Saisie + condition

Saisir et valider un employé

Lisez au clavier le code, le nom, le prénom, l’âge, le salaire et le département. Refusez un âge hors de l’intervalle 18–65 et un salaire négatif. Sinon, affichez la fiche.

  • Utiliser Scanner
  • Combiner les tests avec ||
  • Fermer le scanner à la fin
Voir la solutionavec validation simple
Main.java
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner clavier = new Scanner(System.in);

        System.out.print("Code : ");
        String code = clavier.nextLine();
        System.out.print("Nom : ");
        String nom = clavier.nextLine();
        System.out.print("Prénom : ");
        String prenom = clavier.nextLine();
        System.out.print("Âge : ");
        int age = clavier.nextInt();
        System.out.print("Salaire : ");
        double salaire = clavier.nextDouble();
        clavier.nextLine();
        System.out.print("Département : ");
        String departement = clavier.nextLine();

        if (age < 18 || age > 65 || salaire < 0) {
            System.out.println("Données invalides.");
        } else {
            System.out.printf("%s — %s %s | %d ans | %s | %.2f DH%n",
                code, prenom, nom, age, departement, salaire);
        }

        clavier.close();
    }
}

Point Java : || signifie « ou ». Le nextLine() placé après le salaire consomme le retour à la ligne encore présent.

EX 03Conditions

Calculer une prime

Calculez le salaire final selon le département : Informatique +12 %, Finance +10 %, RH +7 %, autre département +5 %. Le nom du département ne doit pas être sensible aux majuscules.

Voir la solutionavec switch
Extrait à intégrer
double tauxPrime;

switch (departement.toLowerCase()) {
    case "informatique":
        tauxPrime = 0.12;
        break;
    case "finance":
        tauxPrime = 0.10;
        break;
    case "rh":
        tauxPrime = 0.07;
        break;
    default:
        tauxPrime = 0.05;
}

double prime = salaire * tauxPrime;
double salaireFinal = salaire + prime;
System.out.printf("Prime : %.2f DH%n", prime);
System.out.printf("Salaire final : %.2f DH%n", salaireFinal);

Point Java : toLowerCase() normalise le texte. Dans cette syntaxe classique de switch, break empêche de continuer dans le cas suivant.

EX 04Boucles

Traiter plusieurs salaires

Demandez combien d’employés seront saisis. Lisez uniquement leur salaire, puis affichez le total, la moyenne et le salaire le plus élevé.

Indice : initialisez le maximum avec le premier salaire saisi, pas avec une valeur arbitraire.

Voir la solutionboucle for
Main.java
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner clavier = new Scanner(System.in);
        System.out.print("Nombre d'employés : ");
        int nombre = clavier.nextInt();

        if (nombre <= 0) {
            System.out.println("Le nombre doit être positif.");
        } else {
            double total = 0;
            double maximum = 0;

            for (int i = 0; i < nombre; i++) {
                System.out.printf("Salaire %d : ", i + 1);
                double salaire = clavier.nextDouble();
                total += salaire;

                if (i == 0 || salaire > maximum) {
                    maximum = salaire;
                }
            }

            System.out.printf("Total : %.2f DH%n", total);
            System.out.printf("Moyenne : %.2f DH%n", total / nombre);
            System.out.printf("Maximum : %.2f DH%n", maximum);
        }

        clavier.close();
    }
}
✓Point de contrôle 01

Vous savez maintenant déclarer, saisir, afficher, décider et répéter en Java.

PARTIE02

De l’employé unique à la collection

Stocker, parcourir, rechercher

Avant les objets, plusieurs tableaux parallèles permettent de représenter plusieurs employés avec la même position.

Objectif

Conserver jusqu’à 100 employés et exploiter leurs données.

Indice communL’indice 1 désigne le même employé partout.
codes[0] E101[1] E102[2] E103
noms[0] Amrani[1] Idrissi[2] Bennani
salaires[0] 8500[1] 9200[2] 7600
Créer

Capacité fixe

String[] codes = new String[100];double[] salaires = new double[100];int nombreEmployes = 0;

La capacité est 100, mais seules les cases de 0 à nombreEmployes - 1 sont utilisées.

Accéder

Un indice commence à zéro

codes[0] = "E101";System.out.println(codes[0]);salaires[0] += 500;

Accéder à un indice négatif ou supérieur à la taille provoque une erreur.

Parcourir

Utiliser le nombre réel d’éléments

Extrait
for (int i = 0; i < nombreEmployes; i++) {
    System.out.printf("%s — %s — %.2f DH%n",
        codes[i], noms[i], salaires[i]);
}
EX 05Tableaux

Initialiser et afficher l’équipe

Créez les six tableaux nécessaires, enregistrez trois employés directement dans le code, puis affichez une ligne par employé.

Voir la solutiontableaux parallèles
Main.java
public class Main {
    public static void main(String[] args) {
        String[] codes = {"E101", "E102", "E103"};
        String[] noms = {"Amrani", "Idrissi", "Bennani"};
        String[] prenoms = {"Salma", "Yassine", "Nora"};
        int[] ages = {27, 31, 24};
        double[] salaires = {8500, 9200, 7600};
        String[] departements = {"Informatique", "Finance", "RH"};

        for (int i = 0; i < codes.length; i++) {
            System.out.printf("%s — %s %s | %d ans | %s | %.2f DH%n",
                codes[i], prenoms[i], noms[i], ages[i],
                departements[i], salaires[i]);
        }
    }
}

Point Java : codes.length donne la taille du tableau. Ici, toutes les cases sont remplies dès la création.

EX 06Recherche

Rechercher par code

Demandez un code, parcourez le tableau et affichez la fiche correspondante. Si le code est absent, affichez un message clair.

Voir la solutionrecherche séquentielle
Extrait à intégrer
System.out.print("Code recherché : ");
String codeRecherche = clavier.nextLine();
int position = -1;

for (int i = 0; i < nombreEmployes; i++) {
    if (codes[i].equalsIgnoreCase(codeRecherche)) {
        position = i;
        break;
    }
}

if (position == -1) {
    System.out.println("Employé introuvable.");
} else {
    System.out.printf("%s %s — %.2f DH%n",
        prenoms[position], noms[position], salaires[position]);
}

Convention utile : -1 signifie « aucune position trouvée ». equalsIgnoreCase compare le contenu sans tenir compte des majuscules.

EX 07Ajout

Ajouter sans dépasser la capacité

Préparez des tableaux de capacité 100. Ajoutez un employé à la première position libre, après avoir vérifié qu’il reste de la place et que son code n’existe pas déjà.

Voir la solutioncapacité + unicité
Extrait à intégrer
if (nombreEmployes == codes.length) {
    System.out.println("Capacité maximale atteinte.");
} else {
    System.out.print("Nouveau code : ");
    String nouveauCode = clavier.nextLine();
    boolean existe = false;

    for (int i = 0; i < nombreEmployes; i++) {
        if (codes[i].equalsIgnoreCase(nouveauCode)) {
            existe = true;
            break;
        }
    }

    if (existe) {
        System.out.println("Ce code existe déjà.");
    } else {
        codes[nombreEmployes] = nouveauCode;
        System.out.print("Nom : ");
        noms[nombreEmployes] = clavier.nextLine();
        System.out.print("Prénom : ");
        prenoms[nombreEmployes] = clavier.nextLine();
        System.out.print("Âge : ");
        ages[nombreEmployes] = clavier.nextInt();
        System.out.print("Salaire : ");
        salaires[nombreEmployes] = clavier.nextDouble();
        clavier.nextLine();
        System.out.print("Département : ");
        departements[nombreEmployes] = clavier.nextLine();

        nombreEmployes++;
        System.out.println("Employé ajouté.");
    }
}

Ordre important : on écrit à l’indice nombreEmployes, puis on incrémente le compteur.

EX 08Statistiques

Produire un mini-tableau de bord

Affichez la masse salariale, le salaire moyen, l’employé le mieux payé et le nombre d’employés du département Informatique.

Voir la solutionagrégations
Extrait à intégrer
if (nombreEmployes == 0) {
    System.out.println("Aucune donnée disponible.");
} else {
    double masseSalariale = 0;
    int positionMaximum = 0;
    int nombreInformatique = 0;

    for (int i = 0; i < nombreEmployes; i++) {
        masseSalariale += salaires[i];

        if (salaires[i] > salaires[positionMaximum]) {
            positionMaximum = i;
        }
        if (departements[i].equalsIgnoreCase("Informatique")) {
            nombreInformatique++;
        }
    }

    System.out.printf("Masse salariale : %.2f DH%n", masseSalariale);
    System.out.printf("Salaire moyen : %.2f DH%n",
        masseSalariale / nombreEmployes);
    System.out.printf("Salaire maximal : %s %s — %.2f DH%n",
        prenoms[positionMaximum], noms[positionMaximum],
        salaires[positionMaximum]);
    System.out.println("Effectif Informatique : " + nombreInformatique);
}
✓Point de contrôle 02

Vous savez représenter plusieurs employés, les parcourir, les rechercher et produire des indicateurs.

PARTIE03

Du script au programme structuré

Découper, modifier, supprimer

Les méthodes isolent chaque responsabilité. Le programme devient plus lisible, testable et proche de la future organisation objet.

Objectif

Finaliser une gestion CRUD pilotée par un menu.

mainaffiche le menu et orchestre
ajouter(...)afficher(...)rechercher(...)modifier(...)supprimer(...)
Méthode sans résultat

void

static void afficherTitre() {  System.out.println("Employés");}

static permet d’appeler la méthode directement depuis main.

Méthode avec résultat

return

static double calculerPrime(double salaire) {  return salaire * 0.10;}

Le type annoncé avant le nom doit correspondre à la valeur retournée.

Passer un tableau

La méthode reçoit les données nécessaires

Extrait
static int rechercher(String[] codes, int nombre, String code) {
    for (int i = 0; i < nombre; i++) {
        if (codes[i].equalsIgnoreCase(code)) {
            return i;
        }
    }
    return -1;
}
EX 09Méthodes

Extraire l’affichage et la recherche

Créez une méthode afficherEmployes qui affiche toutes les fiches et une méthode rechercher qui retourne la position d’un code ou -1.

Voir la solutiondeux responsabilités
Méthodes à ajouter dans la classe
static void afficherEmployes(
        String[] codes, String[] noms, String[] prenoms,
        int[] ages, double[] salaires, String[] departements,
        int nombre) {
    if (nombre == 0) {
        System.out.println("Aucun employé.");
        return;
    }

    for (int i = 0; i < nombre; i++) {
        System.out.printf("%s — %s %s | %d ans | %s | %.2f DH%n",
            codes[i], prenoms[i], noms[i], ages[i],
            departements[i], salaires[i]);
    }
}

static int rechercher(String[] codes, int nombre, String code) {
    for (int i = 0; i < nombre; i++) {
        if (codes[i].equalsIgnoreCase(code)) {
            return i;
        }
    }
    return -1;
}

Lecture : le return termine immédiatement la méthode. Dans afficherEmployes, il évite d’exécuter la boucle si la liste est vide.

EX 10Modification

Modifier le salaire et le département

Créez une méthode qui reçoit un code, retrouve l’employé, puis demande son nouveau salaire et son nouveau département. Elle retourne true si la modification est réalisée.

Voir la solutionbooléen de réussite
Méthode à ajouter
static boolean modifier(
        Scanner clavier, String[] codes, double[] salaires,
        String[] departements, int nombre, String code) {
    int position = rechercher(codes, nombre, code);
    if (position == -1) {
        return false;
    }

    System.out.print("Nouveau salaire : ");
    double nouveauSalaire = clavier.nextDouble();
    clavier.nextLine();

    if (nouveauSalaire < 0) {
        System.out.println("Salaire invalide.");
        return false;
    }

    System.out.print("Nouveau département : ");
    String nouveauDepartement = clavier.nextLine();
    salaires[position] = nouveauSalaire;
    departements[position] = nouveauDepartement;
    return true;
}
EX 11Suppression

Supprimer sans laisser de trou

Retrouvez la position d’un employé, décalez toutes les cases suivantes d’une position vers la gauche, puis diminuez le nombre d’employés.

Attention : une méthode ne peut pas modifier directement un entier reçu en paramètre. Faites-lui retourner le nouveau nombre.

Voir la solutiondécalage à gauche
Méthode à ajouter
static int supprimer(
        String[] codes, String[] noms, String[] prenoms,
        int[] ages, double[] salaires, String[] departements,
        int nombre, String code) {
    int position = rechercher(codes, nombre, code);
    if (position == -1) {
        return nombre;
    }

    for (int i = position; i < nombre - 1; i++) {
        codes[i] = codes[i + 1];
        noms[i] = noms[i + 1];
        prenoms[i] = prenoms[i + 1];
        ages[i] = ages[i + 1];
        salaires[i] = salaires[i + 1];
        departements[i] = departements[i + 1];
    }

    return nombre - 1;
}

Dans main : écrivez nombreEmployes = supprimer(...); pour conserver la nouvelle valeur.

PROJET FINALCRUD complet

Assembler l’application

Construisez un menu répété jusqu’au choix « Quitter ». Chaque option appelle une méthode : ajouter, afficher, rechercher, modifier ou supprimer.

1. Ajouter2. Afficher3. Rechercher4. Modifier5. Supprimer0. Quitter
Voir le programme completfichier prêt à tester
GestionEmployes.java
import java.util.Scanner;

public class GestionEmployes {
    static final int CAPACITE = 100;

    public static void main(String[] args) {
        Scanner clavier = new Scanner(System.in);
        String[] codes = new String[CAPACITE];
        String[] noms = new String[CAPACITE];
        String[] prenoms = new String[CAPACITE];
        int[] ages = new int[CAPACITE];
        double[] salaires = new double[CAPACITE];
        String[] departements = new String[CAPACITE];
        int nombre = 0;
        int choix;

        do {
            afficherMenu();
            choix = lireEntier(clavier, "Votre choix : ");

            switch (choix) {
                case 1:
                    nombre = ajouter(clavier, codes, noms, prenoms,
                        ages, salaires, departements, nombre);
                    break;
                case 2:
                    afficher(codes, noms, prenoms, ages,
                        salaires, departements, nombre);
                    break;
                case 3:
                    rechercherEtAfficher(clavier, codes, noms, prenoms,
                        ages, salaires, departements, nombre);
                    break;
                case 4:
                    modifier(clavier, codes, salaires, departements, nombre);
                    break;
                case 5:
                    nombre = supprimer(clavier, codes, noms, prenoms,
                        ages, salaires, departements, nombre);
                    break;
                case 0:
                    System.out.println("Au revoir.");
                    break;
                default:
                    System.out.println("Choix invalide.");
            }
        } while (choix != 0);

        clavier.close();
    }

    static void afficherMenu() {
        System.out.println("\n=== GESTION DES EMPLOYÉS ===");
        System.out.println("1. Ajouter");
        System.out.println("2. Afficher");
        System.out.println("3. Rechercher");
        System.out.println("4. Modifier");
        System.out.println("5. Supprimer");
        System.out.println("0. Quitter");
    }

    static int lireEntier(Scanner clavier, String message) {
        System.out.print(message);
        while (!clavier.hasNextInt()) {
            System.out.print("Entier attendu. Réessayez : ");
            clavier.nextLine();
        }
        int valeur = clavier.nextInt();
        clavier.nextLine();
        return valeur;
    }

    static double lireDouble(Scanner clavier, String message) {
        System.out.print(message);
        while (!clavier.hasNextDouble()) {
            System.out.print("Nombre attendu. Réessayez : ");
            clavier.nextLine();
        }
        double valeur = clavier.nextDouble();
        clavier.nextLine();
        return valeur;
    }

    static int rechercher(String[] codes, int nombre, String code) {
        for (int i = 0; i < nombre; i++) {
            if (codes[i].equalsIgnoreCase(code)) {
                return i;
            }
        }
        return -1;
    }

    static int ajouter(
            Scanner clavier, String[] codes, String[] noms,
            String[] prenoms, int[] ages, double[] salaires,
            String[] departements, int nombre) {
        if (nombre == codes.length) {
            System.out.println("Capacité maximale atteinte.");
            return nombre;
        }

        System.out.print("Code : ");
        String code = clavier.nextLine();
        if (code.isBlank() || rechercher(codes, nombre, code) != -1) {
            System.out.println("Code vide ou déjà utilisé.");
            return nombre;
        }

        System.out.print("Nom : ");
        String nom = clavier.nextLine();
        System.out.print("Prénom : ");
        String prenom = clavier.nextLine();
        int age = lireEntier(clavier, "Âge : ");
        double salaire = lireDouble(clavier, "Salaire : ");
        System.out.print("Département : ");
        String departement = clavier.nextLine();

        if (age < 18 || age > 65 || salaire < 0) {
            System.out.println("Âge ou salaire invalide.");
            return nombre;
        }

        codes[nombre] = code;
        noms[nombre] = nom;
        prenoms[nombre] = prenom;
        ages[nombre] = age;
        salaires[nombre] = salaire;
        departements[nombre] = departement;
        System.out.println("Employé ajouté.");
        return nombre + 1;
    }

    static void afficher(
            String[] codes, String[] noms, String[] prenoms,
            int[] ages, double[] salaires, String[] departements,
            int nombre) {
        if (nombre == 0) {
            System.out.println("Aucun employé.");
            return;
        }

        for (int i = 0; i < nombre; i++) {
            afficherFiche(codes, noms, prenoms, ages,
                salaires, departements, i);
        }
    }

    static void afficherFiche(
            String[] codes, String[] noms, String[] prenoms,
            int[] ages, double[] salaires, String[] departements,
            int position) {
        System.out.printf("%s — %s %s | %d ans | %s | %.2f DH%n",
            codes[position], prenoms[position], noms[position],
            ages[position], departements[position], salaires[position]);
    }

    static void rechercherEtAfficher(
            Scanner clavier, String[] codes, String[] noms,
            String[] prenoms, int[] ages, double[] salaires,
            String[] departements, int nombre) {
        System.out.print("Code recherché : ");
        String code = clavier.nextLine();
        int position = rechercher(codes, nombre, code);

        if (position == -1) {
            System.out.println("Employé introuvable.");
        } else {
            afficherFiche(codes, noms, prenoms, ages,
                salaires, departements, position);
        }
    }

    static void modifier(
            Scanner clavier, String[] codes, double[] salaires,
            String[] departements, int nombre) {
        System.out.print("Code à modifier : ");
        String code = clavier.nextLine();
        int position = rechercher(codes, nombre, code);

        if (position == -1) {
            System.out.println("Employé introuvable.");
            return;
        }

        double salaire = lireDouble(clavier, "Nouveau salaire : ");
        if (salaire < 0) {
            System.out.println("Salaire invalide.");
            return;
        }
        System.out.print("Nouveau département : ");
        String departement = clavier.nextLine();

        salaires[position] = salaire;
        departements[position] = departement;
        System.out.println("Employé modifié.");
    }

    static int supprimer(
            Scanner clavier, String[] codes, String[] noms,
            String[] prenoms, int[] ages, double[] salaires,
            String[] departements, int nombre) {
        System.out.print("Code à supprimer : ");
        String code = clavier.nextLine();
        int position = rechercher(codes, nombre, code);

        if (position == -1) {
            System.out.println("Employé introuvable.");
            return nombre;
        }

        for (int i = position; i < nombre - 1; i++) {
            codes[i] = codes[i + 1];
            noms[i] = noms[i + 1];
            prenoms[i] = prenoms[i + 1];
            ages[i] = ages[i + 1];
            salaires[i] = salaires[i + 1];
            departements[i] = departements[i + 1];
        }

        System.out.println("Employé supprimé.");
        return nombre - 1;
    }
}

Tests à effectuer

  1. Ajouter deux employés avec des codes différents.
  2. Refuser un code déjà utilisé.
  3. Rechercher un code présent puis un code absent.
  4. Modifier le salaire d’un employé.
  5. Supprimer le premier employé puis afficher la liste.
  6. Saisir une lettre lorsque le menu attend un entier.
✓Point de contrôle final

Vous disposez maintenant du socle Java nécessaire pour remplacer ces tableaux parallèles par de vrais objets.

04→

Prochaine étape

Passer des tableaux à la classe Employe

Les six tableaux parallèles fonctionnent, mais ils séparent les informations d’une même personne. La programmation orientée objet permettra de les réunir dans une seule structure cohérente.

Avantcodes[i]noms[i]salaires[i]
Ensuiteemploye.getCode()employe.getNom()employe.getSalaire()