LE LANGAGE JAVA

Iadine GOUNDETE
Ingénieur en Architecture Logicielle
[Link]@[Link]
Page 0 sur 64
+229 0197486983
Table des matières
Chapitre 1 – No,ons de base de Java ........................................................................................ 4
1. Introduc,on au langage Java .............................................................................................. 4
2. La machine virtuelle Java (JVM) ......................................................................................... 4
3. Structure d’un programme Java ......................................................................................... 5
4. Variables, constantes et types de données ........................................................................ 5
5. Opérateurs et expressions .................................................................................................. 6
6. Entrées et sor,es standards ............................................................................................... 7
7. Exercices pra,ques ............................................................................................................. 7
À retenir ........................................................................................................................... 8
Chapitre 2 – Les instruc,ons de contrôle ................................................................................... 9
1. Introduc,on ........................................................................................................................ 9
2. Les structures condi,onnelles ............................................................................................ 9
3. L’instruc,on switch ........................................................................................................... 10
4. Les structures itéra,ves (boucles) .................................................................................... 11
5. Instruc,ons de saut .......................................................................................................... 12
6. Portée et durée de vie des variables ................................................................................ 13
7. Exercices pra,ques ........................................................................................................... 14
À retenir ......................................................................................................................... 15
Chapitre 3 – Classes et Objets .................................................................................................. 16
1. Introduc,on ...................................................................................................................... 16
2. Défini,on d’une classe et d’un objet................................................................................ 16
3. Les a@ributs (ou propriétés) ............................................................................................. 17
4. Les méthodes ................................................................................................................... 17
5. Les constructeurs.............................................................................................................. 18
6. Encapsula,on et visibilité ................................................................................................. 19
7. Méthodes et a@ributs sta,ques ....................................................................................... 20
8. Surcharge des méthodes .................................................................................................. 21
9. Passage d’arguments et retour de valeurs ....................................................................... 21
10. Exercices pra,ques ......................................................................................................... 22
À retenir ......................................................................................................................... 23
Chapitre 4 – Héritage, Polymorphisme, Classes Abstraites et Interfaces ................................ 24
Page 1 sur 64
 1. Introduc,on ...................................................................................................................... 24
2. L’héritage en Java ............................................................................................................. 24
3. La redéfini,on de méthodes (override) ........................................................................... 25
4. U,lisa,on du mot-clé super ............................................................................................. 26
5. La hiérarchie de classes .................................................................................................... 27
6. Le polymorphisme ............................................................................................................ 27
7. Classes abstraites.............................................................................................................. 28
8. Les interfaces .................................................................................................................... 29
9. Différence entre classe abstraite et interface .................................................................. 30
10. Exercices pra,ques ......................................................................................................... 30
À retenir ......................................................................................................................... 31
Chapitre 5 – Ges,on des excep,ons et flux d’entrée/sor,e .................................................... 32
1. Introduc,on ...................................................................................................................... 32
2. Structure d’une excep,on ................................................................................................ 32
3. Ges,on des excep,ons : try – catch – finally ................................................................... 32
4. Plusieurs blocs catch......................................................................................................... 33
5. Lancer une excep,on ....................................................................................................... 34
6. Créer ses propres excep,ons ........................................................................................... 35
7. Les flux d’entrée/sor,e (I/O Streams) .............................................................................. 35
8. Lecture et écriture de fichiers texte ................................................................................. 36
9. Lecture et écriture avec BufferedReader et BufferedWriter ............................................ 37
10. Ges,on automa,que des ressources (try-with-resources) ............................................ 38
11. Sérialisa,on d’objets ...................................................................................................... 38
12. Exercices pra,ques ......................................................................................................... 39
À retenir ......................................................................................................................... 40
Chapitre 6 – Les classes usuelles de Java ................................................................................. 41
1. Introduc,on ...................................................................................................................... 41
2. Le package [Link] ......................................................................................................... 41
3. Le package java.u,l........................................................................................................... 42
4. Le package [Link].......................................................................................................... 45
5. Résumé des classes usuelles ............................................................................................ 46
6. Exercices pra,ques ........................................................................................................... 46
Page 2 sur 64
 À retenir ......................................................................................................................... 47
Chapitre 7 – Paquetages et Déploiement ................................................................................ 48
1. Introduc,on ...................................................................................................................... 48
2. Défini,on d’un paquetage ................................................................................................ 48
3. Importa,on des classes d’un paquetage.......................................................................... 49
4. Les paquetages standards de Java.................................................................................... 49
5. Bonnes pra,ques de nommage........................................................................................ 50
6. Exemple complet de projet structuré............................................................................... 50
7. Compila,on et exécu,on avec les paquetages ................................................................ 52
8. Le déploiement en Java .................................................................................................... 52
9. Fichier manifeste ([Link]) .................................................................................... 52
10. Ou,ls de développement (IDE) ...................................................................................... 53
11. Exercices pra,ques ......................................................................................................... 53
À retenir ......................................................................................................................... 54
Mini-projet Java : Ges,on d’Étudiants ..................................................................................... 55
1. Objec,f du projet ............................................................................................................. 55
2. Structure du projet ........................................................................................................... 55
3. Le package model ............................................................................................................. 55
4. Le package service ............................................................................................................ 57
5. Le package u,l .................................................................................................................. 59
6. Le package main ............................................................................................................... 60
7. Fonc,onnalités démontrées............................................................................................. 63
8. Exercices complémentaires .............................................................................................. 63
Ce mini-projet rassemble toutes les no,ons vues : ...................................................... 64

Page 3 sur 64
Chapitre 1 – No ons de base de Java
1. Introduc on au langage Java
Java est un langage de programma on orienté objet, créé par James Gosling en 1995 chez
Sun Microsystems (racheté ensuite par Oracle).
C’est un langage portable, sécurisé et indépendant de la plateforme, ce qui signifie qu’un
même programme Java peut fonc,onner sur Windows, Mac, Linux, ou même sur un
smartphone Android sans modifica,on du code source.

Le slogan de Java résume bien ce@e philosophie :

“Write Once, Run Anywhere” (Écris une fois, exécute partout).

Java est u,lisé dans une grande variété de domaines :

• Applica,ons d’entreprise (serveurs, ERP, etc.)

• Développement Android

• Applica,ons web (via Spring Boot, JSP, etc.)

• Jeux et logiciels éduca,fs

2. La machine virtuelle Java (JVM)

Lorsqu’un programme Java est compilé, il ne produit pas un code exécutable spécifique à un
système d’exploita,on (comme un .exe sous Windows).
Le compilateur Java transforme le code source (.java) en bytecode (.class), un code
intermédiaire interprété par la Java Virtual Machine (JVM).

Le cycle d’exécu on Java

1. Le programmeur écrit le code source dans un fichier .java

2. Le compilateur javac le compile en bytecode .class

3. La JVM exécute ce bytecode sur n’importe quelle machine

Schéma simplifié :

Code source (.java) → Bytecode (.class) → JVM → Exécu,on

Avantages de la JVM

• Portabilité : même bytecode sur toutes les plateformes

• Sécurité : la JVM isole le programme de l’OS

• Ges,on automa,que de la mémoire (Garbage Collector)

Page 4 sur 64
3. Structure d’un programme Java
Un programme Java con,ent toujours une classe principale qui possède une méthode
main().

Exemple simple :

public class Bonjour {

public sta,c void main(String[] args) {

[Link]("Bonjour et bienvenue en Java !");

Explica on :

• public class Bonjour → déclara,on d’une classe nommée Bonjour

• public sta,c void main(String[] args) → point d’entrée du programme

• [Link]() → affiche du texte dans la console

Pour exécuter ce code :

javac [Link]

java Bonjour

4. Variables, constantes et types de données

Défini on

Une variable est une zone mémoire qui stocke une donnée.
Chaque variable doit être déclarée avec un type.

Exemple :

int age = 20;

double prix = 14.75;

char ini,ale = 'A';

boolean majeur = true;

Constantes

Page 5 sur 64
Une constante est une variable dont la valeur ne peut pas changer.
On la déclare avec le mot-clé final.

final double PI = 3.14159;

Types primi fs en Java

Type Taille Exemple Descrip on

byte 1 octet byte b = 10; pe,t en,er

short 2 octets short s = 1000; en,er court

int 4 octets int n = 25000; en,er standard

long 8 octets long distance = 100000L; grand en,er

float 4 octets float note = 15.5f; décimal simple

double 8 octets double pi = 3.14; décimal double précision

char 2 octets char c = 'Z'; caractère unique

boolean 1 bit boolean ok = true; vrai/faux

5. Opérateurs et expressions
Opérateurs arithmé ques

int a = 10, b = 3;

[Link](a + b); // 13

[Link](a / b); // 3

[Link](a % b); // 1

Opérateurs de comparaison

==, !=, <, >, <=, >=

int x = 5;

[Link](x > 3); // true

Opérateurs logiques

&& (et), || (ou), ! (non)

Page 6 sur 64
boolean adulte = (age >= 18) && (age < 65);

Opérateurs d’affecta on

=, +=, -=, *=, /=

int c = 5;

c += 3; // équivaut à c = c + 3

6. Entrées et sor es standards

Affichage (sor e)

[Link]("Bonjour ");

[Link]("le monde !");

Lecture au clavier

Pour lire une donnée saisie par l’u,lisateur, on u,lise la classe Scanner.

import java.u,[Link];

public class Lecture {

public sta,c void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Entrez votre nom : ");

String nom = [Link]();

[Link]("Bienvenue, " + nom + " !");

7. Exercices pra ques

Afficher un message simple
Écrivez un programme qui affiche :

“Bienvenue dans le monde merveilleux de Java !”

Page 7 sur 64
 Somme de deux nombres
Demandez à l’u,lisateur deux en,ers et affichez leur somme.

Exemple a endu :

Entrez le premier nombre : 4

Entrez le second nombre : 9

La somme est : 13

Aire d’un cercle

Écrivez un programme qui lit le rayon d’un cercle et affiche son aire.
(Formule : aire = π * r²)

Conversion de température
Demandez une température en Celsius et affichez son équivalent en Fahrenheit.
(Formule : F = C * 9/5 + 32)

Mini-calculatrice
Demandez à l’u,lisateur deux nombres et une opéra,on (+, -, *, /) puis affichez le résultat.

À retenir
• Java est un langage portable grâce à la JVM.

• Chaque programme Java commence par une classe contenant une méthode main().

• Les variables stockent des données, les constantes sont immuables.

• Les opérateurs perme@ent de manipuler ces données.

• La classe Scanner est u,lisée pour lire les entrées clavier.

Page 8 sur 64
Chapitre 2 – Les instruc ons de contrôle
1. Introduc on
Dans un programme, il est souvent nécessaire de prendre des décisions ou de répéter
certaines ac ons selon des condi,ons.
Les instruc ons de contrôle perme@ent de diriger le flux d’exécu,on du programme :

• en choisissant un chemin parmi plusieurs (if, switch),

• ou en répétant un bloc d’instruc,ons (for, while, do...while).

Ces structures donnent au programme un comportement dynamique et intelligent.

2. Les structures condi onnelles

L’instruc on if

Elle permet d’exécuter un bloc de code seulement si une condi,on est vraie.

int age = 20;

if (age >= 18) {

[Link]("Vous êtes majeur.");

L’instruc on if...else

Elle permet d’exécuter un bloc alterna,f lorsque la condi,on est fausse.

if (age >= 18) {

[Link]("Vous êtes majeur.");

} else {

[Link]("Vous êtes mineur.");

L’instruc on if...else if...else

Elle permet de gérer plusieurs cas possibles.

int note = 14;

Page 9 sur 64
if (note >= 16) {

[Link]("Très bien");

} else if (note >= 12) {

[Link]("Assez bien");

} else if (note >= 10) {

[Link]("Passable");

} else {

[Link]("Ajourné");

L’opérateur ternaire

C’est une forme abrégée du if...else pour affecter une valeur selon une condi,on.

int age = 17;

String statut = (age >= 18) ? "majeur" : "mineur";

[Link]("Vous êtes " + statut);

3. L’instruc on switch
Elle est u,lisée lorsque plusieurs condi,ons portent sur une même variable.
Elle rend le code plus lisible que plusieurs if...else.

int jour = 3;

switch (jour) {

case 1:

[Link]("Lundi");

break;

case 2:

[Link]("Mardi");

break;

Page 10 sur 64
 case 3:

[Link]("Mercredi");

break;

default:

[Link]("Jour inconnu");

Remarque :
L’instruc,on break est essen,elle pour empêcher l’exécu on des cas suivants.
Le mot-clé default sert de cas par défaut si aucune condi,on ne correspond.

4. Les structures itéra ves (boucles)

Les boucles perme@ent de répéter une instruc on plusieurs fois tant qu’une condi,on est
vraie.

La boucle while

On u,lise while quand on ne sait pas à l’avance combien de fois répéter.

int compteur = 1;

while (compteur <= 5) {

[Link]("Compteur = " + compteur);

compteur++;

Ce@e boucle vérifie la condi,on avant chaque itéra,on.

La boucle do...while

Elle s’exécute au moins une fois, même si la condi,on est fausse dès le départ.

int nombre = 1;

do {
Page 11 sur 64
 [Link]("Nombre = " + nombre);

nombre++;

} while (nombre <= 5);

La boucle for

Elle est idéale lorsque le nombre d’itéra,ons est connu à l’avance.

for (int i = 1; i <= 5; i++) {

[Link]("Itéra,on " + i);

Structure générale :
for (ini,alisa,on; condi,on; incrémenta,on) { ... }

Boucle for-each

Elle simplifie le parcours des tableaux ou collec,ons.

String[] fruits = {"Pomme", "Banane", "Mangue"};

for (String f : fruits) {

[Link](f);

5. Instruc ons de saut

break

Sort immédiatement de la boucle en cours.

for (int i = 1; i <= 10; i++) {

if (i == 5) break;

[Link](i);

La boucle s’arrête à 4.

Page 12 sur 64
 con nue

Passe à l’itéra,on suivante sans exécuter le reste du code du bloc.

for (int i = 1; i <= 5; i++) {

if (i == 3) con,nue;

[Link](i);

Le nombre 3 est sauté.

return

Met fin à une méthode avant la fin de son exécu,on.

public sta,c void verifier(int x) {

if (x < 0) {

[Link]("Nombre néga,f !");

return;

[Link]("Nombre posi,f !");

6. Portée et durée de vie des variables

Une variable déclarée à l’intérieur d’un bloc {} n’existe que dans ce bloc.

for (int i = 0; i < 3; i++) {

int x = i * 2;

[Link](x);

// x n’est plus accessible ici

Une variable locale n’est pas connue à l’extérieur du bloc où elle a été déclarée.

Page 13 sur 64
7. Exercices pra ques
Vérifier la majorité
Demandez à l’u,lisateur son âge et affichez s’il est majeur ou mineur.

Calcul de la note
Demandez une note et affichez l’apprécia,on :

• 16–20 : Très bien

• 14–15 : Bien

• 12–13 : Assez bien

• 10–11 : Passable

• < 10 : Ajourné

Table de mul plica on

Demandez un nombre et affichez sa table de mul,plica,on jusqu’à 10.

Exemple a endu :

5x1=5

5 x 2 = 10

...

Somme des en ers pairs

Affichez la somme de tous les nombres pairs de 1 à 100 à l’aide d’une boucle for.

Compteur d’occurrences
Créez un tableau de chaînes de caractères et comptez combien de fois un mot précis
apparaît.

Menu interac f (avec switch)

Écrivez un pe,t menu qui affiche :

1 - Addi,on

2 - Soustrac,on

Page 14 sur 64
3 - Mul,plica,on

4 - Division

0 - Qui@er

L’u,lisateur choisit une op,on, et le programme effectue l’opéra,on correspondante.

À retenir
• Les condi ons (if, switch) perme@ent de faire des choix.

• Les boucles (for, while, do...while) perme@ent de répéter des ac,ons.

• Les instruc,ons break, con,nue et return contrôlent le flux d’exécu,on.

• La portée d’une variable est limitée au bloc où elle est déclarée.

Page 15 sur 64
Chapitre 3 – Classes et Objets
1. Introduc on
Dans la programma,on orientée objet, un programme est vu comme un ensemble d’objets
qui interagissent entre eux.
Chaque objet possède :

• des données (appelées a ributs),

• et des comportements (appelés méthodes).

Une classe est le modèle à par,r duquel les objets sont créés, un peu comme un plan
d’architecte pour construire plusieurs maisons similaires.

2. Défini on d’une classe et d’un objet

Exemple de classe

public class Voiture {

// A@ributs

String marque;

int vitesse;

// Méthode

void demarrer() {

[Link](marque + " démarre à " + vitesse + " km/h !");

Créa on d’un objet

public class TestVoiture {

public sta,c void main(String[] args) {

Voiture v1 = new Voiture(); // créa,on d’un objet

[Link] = "Toyota";

[Link] = 120;

Page 16 sur 64
 [Link]();

Ici, v1 est une instance (un exemplaire) de la classe Voiture.

3. Les a9ributs (ou propriétés)

Les aGributs représentent les caractéris ques d’un objet (nom, âge, couleur, etc.).
Ils sont généralement déclarés en haut de la classe.

public class Etudiant {

String nom;

int age;

double moyenne;

Chaque objet créé à par,r de ce@e classe aura ses propres valeurs pour ces a@ributs.

4. Les méthodes
Les méthodes définissent les ac ons qu’un objet peut effectuer.

public class Etudiant {

String nom;

int age;

double moyenne;

void afficherInfos() {

[Link]("Nom : " + nom);

[Link]("Âge : " + age);

[Link]("Moyenne : " + moyenne);

Page 17 sur 64
5. Les constructeurs
Un constructeur est une méthode spéciale u,lisée pour ini aliser les objets lors de leur
créa,on.
Il porte le même nom que la classe et n’a pas de type de retour.

Exemple :

public class Etudiant {

String nom;

int age;

// Constructeur

public Etudiant(String n, int a) {

nom = n;

age = a;

void afficher() {

[Link](nom + " a " + age + " ans.");

U lisa on :

public class TestEtudiant {

public sta,c void main(String[] args) {

Etudiant e1 = new Etudiant("Amira", 21);

e1.afficher();

Il est possible de définir plusieurs constructeurs dans une même classe : c’est la
surcharge de constructeurs.

Page 18 sur 64
6. Encapsula on et visibilité
Encapsula on

L’encapsula,on consiste à protéger les données d’un objet contre les modifica,ons
extérieures non souhaitées.
On rend les a@ributs privés et on fournit des méthodes d’accès (ge ers et se ers).

Exemple :

public class CompteBancaire {

private double solde;

public void deposer(double montant) {

solde += montant;

public void re,rer(double montant) {

if (montant <= solde) solde -= montant;

else [Link]("Fonds insuffisants !");

public double getSolde() {

return solde;

U lisa on :

public class TestCompte {

public sta,c void main(String[] args) {

CompteBancaire c = new CompteBancaire();

[Link](1000);

Page 19 sur 64
 [Link],rer(300);

[Link]("Solde actuel : " + [Link]());

Modificateurs d’accès

Accessible dans la Même Sous- Autre

Modificateur
classe package classe package

private

default (aucun mot

clé)

protected

public

Bonnes pra ques :

• Déclarer les a@ributs en private

• Définir les méthodes en public

• U,liser des ge@ers/se@ers pour contrôler l’accès

7. Méthodes et a9ributs sta ques

Un élément sta que appar,ent à la classe elle-même et non à un objet par,culier.

Exemple :

public class Calculatrice {

public sta,c double carre(double n) {

return n * n;

public class Test {

Page 20 sur 64
 public sta,c void main(String[] args) {

[Link]([Link](4)); // Pas besoin d’objet

8. Surcharge des méthodes

Deux méthodes peuvent porter le même nom si leurs paramètres diffèrent.

public class Opera,on {

int addi,on(int a, int b) {

return a + b;

double addi,on(double a, double b) {

return a + b;

9. Passage d’arguments et retour de valeurs

Les méthodes peuvent recevoir des paramètres et renvoyer des valeurs.

public class MathU,l {

public int somme(int a, int b) {

return a + b;

public class Test {

public sta,c void main(String[] args) {

MathU,l m = new MathU,l();

Page 21 sur 64
 int s = [Link](4, 7);

[Link]("Somme = " + s);

10. Exercices pra ques

Classe Étudiant
Créer une classe Etudiant avec les a@ributs nom, âge, moyenne.
Implémentez un constructeur, des ge@ers/se@ers et une méthode afficherInfos().

Classe Rectangle
Créer une classe Rectangle avec longueur et largeur.
Ajoutez une méthode aire() et une méthode perimetre().
Testez-la avec plusieurs objets.

Compte Bancaire
Créer une classe Compte avec :

• numCompte, propriétaire, solde

• méthodes : deposer(), re,rer(), afficherSolde()

• protec,on par encapsula,on

Surcharge
Créer une classe Calcul avec deux méthodes addi,on :

• l’une addi,onne deux en,ers,

• l’autre trois en,ers.

Testez les deux versions.

Sta que
Créer une classe Conversion avec une méthode sta,que celsiusVersFahrenheit(double c)
Affichez la conversion d’une valeur donnée.

Page 22 sur 64
 À retenir
• Une classe est un modèle d’objet.

• Un objet est une instance concrète d’une classe.

• Les constructeurs ini,alisent les objets.

• L’encapsula on protège les données internes.

• Les membres sta ques appar,ennent à la classe, pas aux objets.

Page 23 sur 64
Chapitre 4 – Héritage, Polymorphisme, Classes
Abstraites et Interfaces
1. Introduc on
L’un des grands avantages de la programma,on orientée objet est la possibilité de réu liser
le code existant et de le faire évoluer sans tout recommencer.
C’est ce qu’apporte le mécanisme d’héritage.
En Java, une classe peut hériter des propriétés et des comportements d’une autre classe
pour en créer une version plus spécialisée.

2. L’héritage en Java
Défini on

L’héritage est le mécanisme qui permet à une classe fille (ou sous-classe) de récupérer les
a@ributs et méthodes d’une classe mère (ou superclasse).
On u,lise le mot-clé extends pour définir une rela,on d’héritage.

Exemple :

// Classe mère

public class Animal {

void parler() {

[Link]("Un animal fait un son.");

// Classe fille

public class Chien extends Animal {

void aboyer() {

[Link]("Le chien aboie !");

Page 24 sur 64
// Programme principal

public class Test {

public sta,c void main(String[] args) {

Chien c = new Chien();

[Link](); // hérité d’Animal

[Link](); // spécifique à Chien

Ici, Chien hérite de Animal : il a accès à sa méthode parler().

3. La redéfini on de méthodes (override)

Une classe fille peut modifier le comportement d’une méthode héritée.
On parle de redéfini on (overriding).

Exemple :

public class Animal {

void parler() {

[Link]("L’animal s’exprime...");

public class Chat extends Animal {

@Override

void parler() {

[Link]("Le chat miaule !");

Le mot-clé @Override permet d’indiquer explicitement qu’on redéfinit une méthode

existante.

Page 25 sur 64
4. U lisa on du mot-clé super
Le mot-clé super fait référence à la classe parente.

Accéder à une méthode de la classe mère :

public class Chien extends Animal {

@Override

void parler() {

[Link](); // appelle la méthode de la classe mère

[Link]("Le chien aboie !");

Appeler le constructeur de la classe mère :

public class Animal {

String nom;

public Animal(String nom) {

[Link] = nom;

public class Chien extends Animal {

public Chien(String nom) {

super(nom); // Appel du constructeur de Animal

Page 26 sur 64
5. La hiérarchie de classes
Java permet de créer une chaîne d’héritage, mais une seule superclasse par classe (héritage
simple).

Animal

Chien

ChienDeGarde

Java ne supporte pas l’héritage mul,ple de classes, mais il le compense avec les
interfaces (voir plus bas).

6. Le polymorphisme
Défini on

Le polymorphisme permet à une variable de référencer des objets de différents types liés
par héritage.

Exemple :

Animal a = new Chien();

[Link](); // Appelle la méthode parler() de Chien

Même si la variable a est de type Animal, c’est la version spécifique de Chien qui est
exécutée.
C’est ce qu’on appelle le polymorphisme dynamique (liage tardif).

Avantage du polymorphisme

Il permet d’écrire du code générique et extensible :

public void faireParler(Animal a) {

[Link]();

Ce@e méthode peut accepter un Chien, un Chat ou n’importe quel autre Animal sans
modifica,on.

Page 27 sur 64
7. Classes abstraites
Défini on

Une classe abstraite est une classe incomplète qui ne peut pas être instanciée.
Elle sert de modèle commun à plusieurs classes filles.

Elle peut contenir :

• des méthodes concrètes (avec un corps),

• et des méthodes abstraites (sans implémenta,on).

Exemple :

abstract class Forme {

abstract double aire(); // méthode abstraite

void afficher() {

[Link]("Calcul de l’aire d’une forme");

class Cercle extends Forme {

double rayon;

Cercle(double r) { rayon = r; }

@Override

double aire() {

return [Link] * rayon * rayon;

U lisa on :

public class TestForme {

Page 28 sur 64
 public sta,c void main(String[] args) {

Forme f = new Cercle(3);

f.afficher();

[Link]("Aire = " + [Link]());

On ne peut pas faire : Forme f = new Forme(); car Forme est abstraite.

8. Les interfaces
Défini on

Une interface définit un contrat : un ensemble de méthodes que les classes doivent
implémenter.
Toutes les méthodes d’une interface sont abstraites par défaut.

Exemple :

interface Volant {

void voler();

class Avion implements Volant {

public void voler() {

[Link]("L’avion vole dans le ciel !");

U lisa on :

public class Test {

public sta,c void main(String[] args) {

Volant v = new Avion();

[Link]();

Page 29 sur 64
 }

Une classe peut implémenter plusieurs interfaces :

class Oiseau implements Volant, Chantant {

public void voler() { ... }

public void chanter() { ... }

9. Différence entre classe abstraite et interface

Critère Classe abstraite Interface

Con,ent des a@ributs ? Oui Non (sauf constantes final)

Con,ent des méthodes

Oui Depuis Java 8, possible avec default
concrètes ?

Oui (plusieurs interfaces peuvent

Héritage mul,ple ? Non
être implémentées)

Modèle commun
U,lisa,on principale Contrat de comportement
par,ellement implémenté

10. Exercices pra ques

Héritage simple
Créez une classe Personne (nom, âge) et une sous-classe Employe (salaire).
Affichez les informa,ons complètes d’un employé.

Redéfini on de méthode
Créez une classe Animal avec une méthode parler().
Faites hériter Chat et Chien d’Animal et redéfinissez parler() dans chaque sous-classe.

Classe abstraite
Créez une classe abstraite Forme avec une méthode abstraite aire().
Implémentez Rectangle et Cercle et affichez leur aire respec,ve.

Page 30 sur 64
 Interface
Créez une interface Deplacable avec une méthode seDeplacer().
Faites l’implémenter par Voiture et Avion et testez leurs comportements.

Polymorphisme
Créez une méthode afficherAire(Forme f) qui reçoit n’importe quelle forme (Cercle,
Rectangle, Triangle) et affiche son aire sans savoir sa nature exacte.

À retenir
• extends = héritage de classes

• implements = implémenta,on d’interfaces

• Le polymorphisme permet un comportement différent pour un même appel

• Les classes abstraites servent de modèle, les interfaces de contrat

Page 31 sur 64
Chapitre 5 – Ges on des excep ons et flux
d’entrée/sor e
1. Introduc on
Lorsqu’un programme Java s’exécute, il peut rencontrer des situa,ons anormales :

• division par zéro,

• accès à un fichier inexistant,

• saisie invalide de l’u,lisateur, etc.

Ces situa,ons génèrent des excep ons.

Une excep on est un événement inaGendu qui interrompt le déroulement normal du
programme.

Java dispose d’un système puissant de ges on des excep ons perme@ant de détecter,
traiter et prévenir ces erreurs.

2. Structure d’une excep on

Une excep,on en Java est un objet issu de la classe Throwable, qui se divise en deux
branches principales :

Throwable

├── Error → erreurs graves (ex. mémoire insuffisante)

└── Excep,on → erreurs dues au programme ou à l’u,lisateur

Types d’excep ons

• Excep ons vérifiées (checked) : détectées à la compila,on (ex. IOExcep,on)

• Excep ons non vérifiées (unchecked) : détectées à l’exécu,on (ex.

Arithme,cExcep,on, NullPointerExcep,on)

3. Ges on des excep ons : try – catch – finally

Syntaxe générale :

try {

// Code suscep,ble de générer une excep,on

} catch (TypeExcep,on e) {
Page 32 sur 64
 // Traitement de l’excep,on

} finally {

// Code exécuté dans tous les cas

Exemple :

public class Division {

public sta,c void main(String[] args) {

try {

int a = 10, b = 0;

int c = a / b; // Erreur : division par zéro

[Link]("Résultat = " + c);

} catch (Arithme,cExcep,on e) {

[Link]("Erreur : division par zéro !");

} finally {

[Link]("Bloc finally exécuté.");

Le bloc finally s’exécute toujours, qu’une excep,on soit levée ou non.

4. Plusieurs blocs catch

Il est possible de gérer différents types d’excep,ons dans des blocs catch séparés.

try {

int[] tab = new int[3];

tab[4] = 10; // Erreur

} catch (Arithme,cExcep,on e) {

[Link]("Erreur arithmé,que !");

} catch (ArrayIndexOutOfBoundsExcep,on e) {

Page 33 sur 64
 [Link]("Indice du tableau invalide !");

} catch (Excep,on e) {

[Link]("Erreur générale : " + [Link]());

L’ordre des catch est important : toujours placer le plus général (Excep,on) en dernier.

5. Lancer une excep on

On peut déclencher manuellement une excep,on à l’aide du mot-clé throw.

public class Banque {

double solde = 1000;

void re,rer(double montant) throws Excep,on {

if (montant > solde)

throw new Excep,on("Fonds insuffisants !");

solde -= montant;

public sta,c void main(String[] args) {

Banque b = new Banque();

try {

[Link],rer(1500);

} catch (Excep,on e) {

[Link]([Link]());

Page 34 sur 64
6. Créer ses propres excep ons
On peut définir des excep ons personnalisées en héritant de Excep,on.

class SoldeInsuffisantExcep,on extends Excep,on {

public SoldeInsuffisantExcep,on(String message) {

super(message);

U,lisa,on :

public class Compte {

double solde = 500;

void re,rer(double montant) throws SoldeInsuffisantExcep,on {

if (montant > solde)

throw new SoldeInsuffisantExcep,on("Solde insuffisant !");

solde -= montant;

7. Les flux d’entrée/sor e (I/O Streams)

Les flux (streams) perme@ent d’échanger des données entre un programme et des
périphériques (clavier, fichiers, réseau, etc.).
Un flux est une séquence ordonnée d’octets.

Types de flux :

Type Direc on Classe de base

Flux d’entrée Lecture de données InputStream, Reader

Flux de sor,e Écriture de données OutputStream, Writer

Page 35 sur 64
8. Lecture et écriture de fichiers texte
Écriture dans un fichier (FileWriter)

import [Link];

import [Link],on;

public class EcritureFichier {

public sta,c void main(String[] args) {

try {

FileWriter fw = new FileWriter("[Link]");

[Link]("Bonjour, ceci est un test d’écriture en Java !");

[Link]();

[Link]("Fichier écrit avec succès !");

} catch (IOExcep,on e) {

[Link]("Erreur d’écriture : " + [Link]());

Lecture d’un fichier (FileReader)

import [Link];

import [Link],on;

public class LectureFichier {

public sta,c void main(String[] args) {

try {

FileReader fr = new FileReader("[Link]");

int caractere;

while ((caractere = [Link]()) != -1) {

Page 36 sur 64
 [Link]((char) caractere);

[Link]();

} catch (IOExcep,on e) {

[Link]("Erreur de lecture : " + [Link]());

9. Lecture et écriture avec BufferedReader et BufferedWriter

Ces classes perme@ent d’améliorer les performances grâce à une mise en mémoire tampon.

import [Link].*;

public class FichierBuffer {

public sta,c void main(String[] args) {

try {

BufferedWriter bw = new BufferedWriter(new FileWriter("[Link]"));

[Link]("Maths : 15\nPhysique : 14");

[Link]();

BufferedReader br = new BufferedReader(new FileReader("[Link]"));

String ligne;

while ((ligne = [Link]()) != null) {

[Link](ligne);

[Link]();

} catch (IOExcep,on e) {

[Link]();

Page 37 sur 64
 }

10. Ges on automa que des ressources (try-with-resources)

Depuis Java 7, on peut ouvrir automa,quement les fichiers avec la syntaxe suivante :
Les ressources sont fermées automa quement à la fin du bloc try.

import [Link].*;

public class ExempleTryAuto {

public sta,c void main(String[] args) {

try (BufferedWriter bw = new BufferedWriter(new FileWriter("[Link]"))) {

[Link]("Fermeture automa,que du flux !");

} catch (IOExcep,on e) {

[Link]();

11. Sérialisa on d’objets

La sérialisa on permet d’enregistrer un objet en er dans un fichier (a@ributs inclus).
L’objet doit implémenter l’interface Serializable.

Exemple :

import [Link].*;

class Etudiant implements Serializable {

String nom;

int age;

Page 38 sur 64
 public Etudiant(String nom, int age) {

[Link] = nom;

[Link] = age;

public class SauvegardeObjet {

public sta,c void main(String[] args) {

try (ObjectOutputStream oos =

new ObjectOutputStream(new FileOutputStream("[Link]"))) {

Etudiant e = new Etudiant("Alice", 22);

[Link](e);

[Link]("Objet sauvegardé !");

} catch (IOExcep,on ex) {

[Link]();

Pour relire cet objet, on u,lise ObjectInputStream.

12. Exercices pra ques

Ges on des erreurs
Écrivez un programme qui divise deux nombres et gère la division par zéro avec try...catch.

Fichier texte
Créez un fichier [Link] contenant trois prénoms, puis lisez et affichez-les ligne par ligne.

Copie de fichier
Écrivez un programme qui lit un fichier et en écrit une copie dans un autre fichier.
Page 39 sur 64
 Sérialisa on
Créez une classe Employe (nom, salaire) et sauvegardez un objet Employe dans un fichier
binaire.

Excep on personnalisée
Créez une excep,on AgeInvalideExcep,on levée si l’u,lisateur entre un âge néga,f.

À retenir
• Les excep,ons perme@ent de rendre les programmes plus sûrs.

• Le bloc try...catch...finally permet de contrôler les erreurs.

• throw et throws servent à lancer et propager des excep,ons.

• Les flux (InputStream, OutputStream) servent à lire et écrire des données.

• Le try-with-resources gère automa,quement la fermeture des fichiers.

Page 40 sur 64
Chapitre 6 – Les classes usuelles de Java
1. Introduc on
Java met à disposi,on un ensemble très riche de classes prêtes à l’emploi regroupées dans
des bibliothèques (packages).
Les plus u,lisées sont :

• [Link] → classes de base (String, Math, Object, etc.)

• java.u l → structures de données et ou,ls divers (List, Map, Scanner, Date, etc.)

• [Link] → formatage de nombres, dates et textes

Ce chapitre présente les classes les plus importantes pour rendre ton code plus efficace, plus
clair et plus moderne.

2. Le package [Link]
Ce package est importé automa quement dans tous les programmes Java.
Il con,ent les classes fondamentales : String, Math, Object, System, Integer, etc.

La classe String

Une chaîne de caractères (String) est un objet immuable : son contenu ne peut pas être
modifié après sa créa,on.

String nom = "Java";

[Link]([Link]()); // JAVA

[Link]([Link]()); // 4

[Link]([Link](1)); // a

[Link]([Link]("java")); // false

Pour des chaînes modifiables, on peut u,liser StringBuilder ou StringBuffer :

StringBuilder sb = new StringBuilder("Bonjour");

[Link](" tout le monde!");

[Link](sb);

La classe Math

Page 41 sur 64
La classe Math fournit des méthodes sta ques pour les calculs mathéma,ques :

[Link]([Link](16)); // racine carrée

[Link]([Link](2, 3)); // puissance

[Link]([Link](5, 9)); // maximum

[Link]([Link]()); // nombre aléatoire entre 0 et 1

La classe System

Permet d’interagir avec la machine virtuelle :

[Link]("Bonjour !");

[Link]("Temps actuel : " + [Link]());

3. Le package java.u l
Ce package con,ent des classes très puissantes pour manipuler :

• les collec ons (List, Set, Map),

• les dates et calendriers,

• les u litaires comme Scanner, Random, etc.

La classe Scanner

Permet de lire les données saisies par l’u,lisateur :

import java.u,[Link];

public class ExempleScanner {

public sta,c void main(String[] args) {

Scanner sc = new Scanner([Link]);

[Link]("Entrez votre nom : ");

String nom = [Link]();

[Link]("Bonjour " + nom + " !");

Page 42 sur 64
}

Les listes : ArrayList

Une ArrayList est une liste dynamique qui peut grandir ou rétrécir.

import java.u,[Link];

public class ListeExemple {

public sta,c void main(String[] args) {

ArrayList<String> fruits = new ArrayList<>();

[Link]("Pomme");

[Link]("Mangue");

[Link]("Orange");

for (String f : fruits)

[Link](f);

[Link]("Mangue");

[Link]("Après suppression : " + fruits);

Avantage : on peut accéder à chaque élément avec un indice :

[Link]([Link](0)); // Pomme

Les ensembles : HashSet

Un HashSet est une collec,on sans doublons.

import java.u,[Link];

public class Ensemble {

Page 43 sur 64
 public sta,c void main(String[] args) {

HashSet<Integer> nombres = new HashSet<>();

[Link](1);

[Link](2);

[Link](2);

[Link](nombres); // [1, 2]

Les dic onnaires : HashMap

Un HashMap stocke des paires clé → valeur.

import java.u,[Link];

public class Dic,onnaire {

public sta,c void main(String[] args) {

HashMap<String, Integer> notes = new HashMap<>();

[Link]("Alice", 15);

[Link]("Bob", 12);

[Link]([Link]("Alice")); // 15

[Link]([Link]()); // [Alice, Bob]

Très u,le pour représenter des fichiers d’élèves, produits, etc.

La classe Random

Permet de générer des nombres aléatoires.

import java.u,[Link];

Page 44 sur 64
Random r = new Random();

int n = [Link](10); // entre 0 et 9

[Link]("Nombre aléatoire : " + n);

Les dates : Date et Calendar

import java.u,[Link];

import java.u,[Link];

public class Dates {

public sta,c void main(String[] args) {

Date maintenant = new Date();

[Link]("Date actuelle : " + maintenant);

Calendar c = [Link]();

[Link](2025, [Link], 1);

[Link]("Nouvel an : " + [Link]());

Depuis Java 8, on préfère u,liser le package java.,me (LocalDate, LocalTime,

LocalDateTime).

4. Le package [Link]
Ce package permet de formater et analyser des chaînes, nombres et dates.

La classe DecimalFormat

import [Link];

DecimalFormat df = new DecimalFormat("#.##");

Page 45 sur 64
double n = 12.3456;

[Link]([Link](n)); // 12.35

La classe SimpleDateFormat

import [Link];

import java.u,[Link];

SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");

[Link]("Date formatée : " + [Link](new Date()));

5. Résumé des classes usuelles

Package Classe U lité principale

[Link] String, Math, System Fonc,ons de base du langage

java.u,l Scanner, ArrayList, HashMap, Random Entrée u,lisateur, collec,ons, aléatoire

java.u,l Date, Calendar Ges,on du temps

[Link] DecimalFormat, SimpleDateFormat Formatage de nombres et dates

6. Exercices pra ques

Manipula on de chaînes
Demandez à l’u,lisateur une phrase et :

• affichez sa longueur,

• me@ez-la en majuscules,

• et comptez combien de fois la le@re a apparaît.

Liste d’étudiants
Créez une ArrayList contenant des noms d’étudiants.
Ajoutez-en, supprimez-en un, puis affichez la liste finale.

Page 46 sur 64
 Annuaire téléphonique
U,lisez un HashMap<String, String> pour stocker des paires (Nom → Numéro).
Ajoutez trois contacts et affichez-les.

Formatage de nombres
Affichez la valeur de π ([Link]) arrondie à 3 décimales.

Date et heure
Affichez la date du jour formatée ainsi :
"Nous sommes le lundi 06 octobre 2025 à 10:30:15"

À retenir
• [Link] con,ent les classes fondamentales du langage.

• java.u,l fournit des structures de données et ou,ls très u,lisés.

• [Link] permet de formater et d’analyser des données.

• Ces classes rendent les programmes plus structurés, dynamiques et lisibles.

Page 47 sur 64
Chapitre 7 – Paquetages et Déploiement
1. Introduc on
Au fur et à mesure qu’un projet Java grandit, le nombre de classes augmente rapidement.
Pour éviter le désordre et les conflits de noms, Java propose les paquetages (packages) :
→ ce sont des espaces logiques qui perme@ent de regrouper les classes par thème ou par
fonc onnalité.

Le déploiement, quant à lui, consiste à préparer le programme pour sa distribu on ou son

exécu on sur une autre machine (par exemple sous forme de fichier .jar).

2. Défini on d’un paquetage

Un paquetage est un regroupement de classes dans un même espace de noms.
Chaque fichier Java commence par une ligne package.

Exemple :

package [Link];

public class Voiture {

public void demarrer() {

[Link]("La voiture démarre !");

Structure du projet :

src/

└── com/

└── jahaClinique/

└── vehicules/

└── [Link]

Chaque dossier correspond à un niveau du nom de package.

Page 48 sur 64
3. Importa on des classes d’un paquetage
Si tu veux u,liser une classe d’un autre package, tu dois l’importer.

Exemple :

package [Link];

import [Link];

public class TestVoiture {

public sta,c void main(String[] args) {

Voiture v = new Voiture();

[Link]();

Importa on mul ple :

import [Link].*;

* signifie “toutes les classes du paquetage”, mais pas celles des sous-packages.

4. Les paquetages standards de Java

Java dispose d’un grand nombre de packages intégrés.
Voici quelques-uns des plus u,lisés :

Package Contenu principal

[Link] Classes de base : String, Math, Object

java.u,l Collec,ons, Scanner, Random, Date

[Link] Entrées/sor,es (fichiers)

[Link] Communica,on réseau

[Link], [Link] Interfaces graphiques

[Link] Connexion aux bases de données

Page 49 sur 64
5. Bonnes pra ques de nommage
1. Toujours u,liser des noms de paquetages en minuscules.

2. U,liser le nom de domaine inversé pour éviter les collisions.

o Exemple : [Link],onPa,ents

3. Regrouper les classes par rôle :

o model → classes mé,er (ex. Pa,ent, Medecin)

o dao → classes d’accès aux données

o service → logique mé,er

o ui → interface u,lisateur

6. Exemple complet de projet structuré

Arborescence :

src/

├── model/

│ └── [Link]

├── service/

│ └── Ges,[Link]

└── main/

└── Applica,[Link]

model/[Link]

package model;

public class Etudiant {

private String nom;

private double moyenne;

Page 50 sur 64
 public Etudiant(String nom, double moyenne) {

[Link] = nom;

[Link] = moyenne;

public void afficher() {

[Link](nom + " a une moyenne de " + moyenne);

service/Ges [Link]

package service;

import [Link];

public class Ges,onEtudiant {

public void resultat(Etudiant e) {

if (e != null) e.afficher();

main/Applica [Link]

package main;

import [Link];

import [Link],onEtudiant;

public class Applica,on {

Page 51 sur 64
 public sta,c void main(String[] args) {

Etudiant e = new Etudiant("Alice", 15.2);

Ges,onEtudiant g = new Ges,onEtudiant();

[Link](e);

7. Compila on et exécu on avec les paquetages

Depuis le répertoire src, on peut compiler tout le projet :

javac model/*.java service/*.java main/*.java

Puis exécuter le programme :

java [Link],on

A@en,on : il faut respecter la structure des dossiers correspondant aux packages.

8. Le déploiement en Java
Une fois ton projet prêt, tu peux le regrouper dans un fichier exécutable appelé JAR (Java
ARchive).

Créa on d’un fichier JAR

Depuis ton répertoire compilé (bin ou out), exécute :

jar cvfe [Link] [Link],on main/*.class model/*.class service/*.class

Exécu on du JAR :

java -jar [Link]

Tu peux double-cliquer sur le fichier .jar pour l’exécuter s’il con,ent la bonne entrée
Main-Class.

9. Fichier manifeste ([Link])

Le fichier [Link] décrit les métadonnées du JAR : version, auteur, et surtout la classe
principale.

Page 52 sur 64
Exemple :

Manifest-Version: 1.0

Main-Class: [Link],on

10. Ou ls de développement (IDE)

Les IDE (Environnements de Développement Intégré) facilitent la ges,on des packages et du
déploiement :

IDE Avantages principaux

Eclipse Gratuit, complet, parfait pour les étudiants

IntelliJ IDEA Très fluide, u,lisé en entreprise

NetBeans Intégré à Java, facile à apprendre

Tous ces ou,ls peuvent compiler, exécuter et générer des fichiers JAR
automa,quement.

11. Exercices pra ques

Organisa on en paquetages
Crée un projet avec trois packages :

• model → classe Produit (nom, prix)

• service → classe Ges,onProduit

• app → classe Applica,on (méthode main)

Testez l’affichage des produits.

U lisa on de packages standards

U,lise java.u,[Link] pour lire des données et [Link] pour afficher le
prix avec deux décimales.

Déploiement
Compile ton projet, crée un fichier .jar exécutable et teste-le avec java -jar.

Page 53 sur 64
 Exercice bonus
Crée un projet de ges,on de bibliothèque avec :

• model : Livre, Auteur

• service : Ges,onBibliotheque

• main : Applica,on

Chaque classe doit avoir au moins une méthode significa,ve (ex. ajouterLivre(),
afficherAuteurs()).

À retenir
• Les packages structurent le code et évitent les conflits.

• Le déploiement JAR permet de distribuer une applica,on complète.

• Les IDE facilitent le développement et l’exporta,on de projets.

Page 54 sur 64
Mini-projet Java : Ges on d’Étudiants
1. Objec f du projet
L’objec,f est de concevoir une applica on console capable de :

• Gérer une liste d’étudiants (ajout, suppression, recherche),

• Calculer des moyennes,

• Sauvegarder et charger les données à par,r d’un fichier texte,

• U,liser une structure bien organisée avec plusieurs packages.

2. Structure du projet
src/

├── model/

│ ├── [Link]

│ └── [Link]

├── service/

│ └── Ges,[Link]

├── u,l/

│ └── FichierU,[Link]

└── main/

└── Applica,[Link]

Chaque dossier représente un package Java.

3. Le package model
[Link]

package model;

public class Personne {

protected String nom;

Page 55 sur 64
 protected int age;

public Personne(String nom, int age) {

[Link] = nom;

[Link] = age;

public String getNom() { return nom; }

public int getAge() { return age; }

public void afficher() {

[Link]("Nom : " + nom + ", Âge : " + age);

[Link]

package model;

public class Etudiant extends Personne {

private double note1;

private double note2;

public Etudiant(String nom, int age, double note1, double note2) {

super(nom, age);

this.note1 = note1;

this.note2 = note2;

Page 56 sur 64
 public double calculerMoyenne() {

return (note1 + note2) / 2;

@Override

public void afficher() {

[Link]("Étudiant : " + nom + " (" + age + " ans)");

[Link]("Moyenne : " + calculerMoyenne());

@Override

public String toString() {

return nom + ";" + age + ";" + note1 + ";" + note2;

public sta,c Etudiant fromString(String ligne) {

String[] t = [Link](";");

return new Etudiant(t[0], [Link](t[1]),

[Link](t[2]), [Link](t[3]));

4. Le package service
Ges [Link]

package service;

import [Link];

import java.u,[Link];

Page 57 sur 64
public class Ges,onEtudiant {

private ArrayList<Etudiant> liste = new ArrayList<>();

public void ajouter(Etudiant e) {

[Link](e);

public void afficherTous() {

if ([Link]())

[Link]("Aucun étudiant enregistré.");

else

for (Etudiant e : liste)

e.afficher();

public Etudiant rechercher(String nom) {

for (Etudiant e : liste)

if ([Link]().equalsIgnoreCase(nom))

return e;

return null;

public void supprimer(String nom) {

Etudiant e = rechercher(nom);

if (e != null) {

[Link](e);

[Link]("Étudiant supprimé avec succès !");

Page 58 sur 64
 } else {

[Link]("Étudiant introuvable !");

public ArrayList<Etudiant> getListe() {

return liste;

5. Le package u l
FichierU [Link]

package u,l;

import [Link];

import [Link].*;

import java.u,[Link];

public class FichierU,l {

public sta,c void sauvegarder(ArrayList<Etudiant> liste, String fichier) {

try (BufferedWriter bw = new BufferedWriter(new FileWriter(fichier))) {

for (Etudiant e : liste)

[Link]([Link]() + "\n");

[Link]("Données sauvegardées dans " + fichier);

} catch (IOExcep,on e) {

[Link]("Erreur de sauvegarde : " + [Link]());

Page 59 sur 64
 }

public sta,c ArrayList<Etudiant> charger(String fichier) {

ArrayList<Etudiant> liste = new ArrayList<>();

try (BufferedReader br = new BufferedReader(new FileReader(fichier))) {

String ligne;

while ((ligne = [Link]()) != null)

[Link]([Link](ligne));

[Link]("Données chargées depuis " + fichier);

} catch (IOExcep,on e) {

[Link]("Erreur de lecture : " + [Link]());

return liste;

6. Le package main
Applica [Link]

package main;

import [Link];

import [Link],onEtudiant;

import u,[Link],l;

import java.u,[Link];

public class Applica,on {

public sta,c void main(String[] args) {

Page 60 sur 64
Ges,onEtudiant ges,on = new Ges,onEtudiant();

Scanner sc = new Scanner([Link]);

int choix;

do {

[Link]("\n=== MENU GESTION D'ÉTUDIANTS ===");

[Link]("1. Ajouter un étudiant");

[Link]("2. Afficher la liste");

[Link]("3. Rechercher un étudiant");

[Link]("4. Supprimer un étudiant");

[Link]("5. Sauvegarder");

[Link]("6. Charger depuis fichier");

[Link]("0. Qui@er");

[Link]("Votre choix : ");

choix = [Link]();

[Link](); // vider le buffer

switch (choix) {

case 1:

[Link]("Nom : ");

String nom = [Link]();

[Link]("Âge : ");

int age = [Link]();

[Link]("Note 1 : ");

double n1 = [Link]();

[Link]("Note 2 : ");

double n2 = [Link]();

ges,[Link](new Etudiant(nom, age, n1, n2));

Page 61 sur 64
 break;

case 2:

ges,on.afficherTous();

break;

case 3:

[Link]("Nom à rechercher : ");

String rech = [Link]();

Etudiant e = ges,[Link](rech);

if (e != null) e.afficher();

else [Link]("Étudiant non trouvé.");

break;

case 4:

[Link]("Nom à supprimer : ");

String del = [Link]();

ges,[Link](del);

break;

case 5:

FichierU,[Link](ges,[Link](), "[Link]");

break;

case 6:

ges,[Link]().clear();

ges,[Link]().addAll(FichierU,[Link]("[Link]"));

break;

Page 62 sur 64
 case 0:

[Link]("Fin du programme !");

break;

default:

[Link]("Choix invalide !");

} while (choix != 0);

7. Fonc onnalités démontrées

Fonc onnalité Élément du projet

Classes, héritage, encapsula,on Personne, Etudiant

Collec,ons (ArrayList) Ges,onEtudiant

Excep,ons et flux FichierU,l

Packages et importa,ons model, service, u,l, main

Lecture u,lisateur Scanner

Déploiement possible en .jar Applica,[Link] (classe principale)

8. Exercices complémentaires
Tri des étudiants
Ajoute une méthode dans Ges,onEtudiant pour trier les étudiants selon leur moyenne
(u,lise Collec,[Link] et un Comparator).

Interface graphique (bonus)

Conver,s le menu console en interface Swing simple avec des boutons et champs de texte.

Page 63 sur 64
 Ges on d’erreurs
Ajoute une vérifica,on pour éviter les notes néga,ves ou supérieures à 20.

Sauvegarde automa que

Fais en sorte que le programme sauvegarde les données automa,quement à la fermeture.

Ce mini-projet rassemble toutes les no ons vues :

• la POO,

• la ges,on des excep,ons,

• la manipula,on de fichiers,

• les collec,ons,

• et les packages.

Page 64 sur 64