Java VF

DDOAM M201
Cours JAVA
[email protected]
[email protected]
Sommaire :Cours DDOAM
2
 PARTIE 1: Présentation de java
 PARTIE 2: les notions de base
 PARTIE 3:Introduire les interfaces graphiques
 PARTIE 4: Les fondamentaux de java
 PARTIE 5:Programmation orienté objet
 PARTIE 6:Correspondance UML-JAVA
 PARTIE 7:Les collections et les expressions lambda
 PARTIE 8:Les Fichiers et les threads
 PARTIE 9:Initialisation du Framework Spring Boot
 PARTIE 10:Préparer les projets et les examens
Sommaire: Exercices pratiques et TP
[email protected]
3
 EP01  EP14  TP01
 EP02  EP15  TP02
 EP03  EP16  TP03
 EP04  EP17  TP04
 EP05  EP18  TP05
 EP06  EP19  TP06
 EP07  EP20  TAF01
 EP08  EP21  TAF02
 EP09  EP22  TAF03
 EP10  EP23  PAF01
 EP11  EP24  PAF02
 EP12  EP25
 EP13
COURS EP&TP
[email protected]
PARTIE 1 :
PRESENTATION DE JAVA
COURS EP&TP
Les caractéristiques
5
le source est compilé en pseudo code ou bytecode puis exécuté par un interpréteur Java : la
Java Virtual Machine (JVM). Ce concept est à la base du slogan de Sun pour Java : WORA (Write
Java est interprété Once, Run Anywhere : écrire une fois, exécuter partout). En effet, le bytecode, s'il ne contient
pas de code spécifique à une plate-forme particulière peut être exécuté et obtenir quasiment
les mêmes résultats sur toutes les machines disposant d'une JVM.
il n'y a pas de compilation spécifique pour chaque plate forme. Le code reste indépendant de la
Java est portable : il est
machine sur laquelle il s'exécute. Il est possible d'exécuter des programmes Java sur tous les
indépendant de toute
environnements qui possèdent une Java Virtual Machine. Cette indépendance est assurée au
plate-forme
niveau du code source grâce à Unicode et au niveau du bytecode.
comme la plupart des langages récents, Java est orienté objet. Chaque fichier source contient la
définition d'une ou plusieurs classes qui sont utilisées les unes avec les autres pour former une
Java est orienté objet.
application. Java n'est pas complètement objet car il définit des types primitifs (entier, caractère,
flottant, booléen,...).
le choix de ses auteurs a été d'abandonner des éléments mal compris ou mal exploités des
Java est simple autres langages tels que la notion de pointeurs (pour éviter les incidents en manipulant
directement la mémoire), l'héritage multiple et la surcharge des opérateurs, ...
[email protected]
COURS EP&TP
6
toutes les variables sont typées et il n'existe pas de conversion automatique qui risquerait une perte
Java est fortement
de données. Si une telle conversion doit être réalisée, le développeur doit obligatoirement utiliser un
typé
cast ou une méthode statique fournie en standard pour la réaliser.
l'allocation de la mémoire pour un objet est automatique à sa création et Java récupère
Java assure la gestion
automatiquement la mémoire inutilisée grâce au garbage collector qui restitue les zones de
de la mémoire
mémoire laissées libres suite à la destruction des objets.
•la sécurité fait partie intégrante du système d'exécution et du compilateur. Un programme Java
planté ne menace pas le système d'exploitation. Il ne peut pas y avoir d'accès direct à la mémoire.
L'accès au disque dur est réglementé dans une applet.
Les applets fonctionnant sur le Web sont soumises aux restrictions suivantes dans la version 1.0 de
Java est sûr
Java :aucun programme ne peut ouvrir, lire, écrire ou effacer un fichier sur le système de l'utilisateur
•aucun programme ne peut lancer un autre programme sur le système de l'utilisateur
•toute fenêtre créée par le programme est clairement identifiée comme étant une fenêtre Java, ce
qui interdit par exemple la création d'une fausse fenêtre demandant un mot de passe
•les programmes ne peuvent pas se connecter à d'autres sites Web que celui dont ils proviennent.
le pseudo code a une taille relativement petite car les bibliothèques de classes requises ne sont liées
Java est économe
qu'à l'exécution.
il permet l'utilisation de threads qui sont des unités d'exécutions isolées. La JVM, elle même, utilise
Java est multitâche
plusieurs threads.
[email protected]
COURS EP&TP
7
Java possède un certain nombre de caractéristiques qui ont largement contribué à son énorme succès :
Il existe 2 types de programmes avec la version standard de Java :
les applets et les applications.
Une application autonome (stand alone program) est une application qui s'exécute sous le contrôle direct du système
d'exploitation.
Une applet est une application qui est chargée par un navigateur et qui est exécutée sous le contrôle d'un plug in de ce
dernier.
Les principales différences entre une applet et une application sont :

•les applets n'ont pas de méthode main() : la méthode main() est appelée par la machine virtuelle pour exécuter une
application.
•les applets ne peuvent pas être testées avec l'interpréteur. Elles doivent être testées avec l'applet viewer ou doivent
être intégrées à une page HTML, elle même visualisée avec un navigateur disposant d'un plug in Java,
[email protected]
COURS EP&TP
Logos JAVA
8
Java a connu deux logos au cours de son histoire.
de 1996 à 2003 à partir de 2003
[email protected]
COURS EP&TP
[email protected] Historique
9
Depuis sa première diffusion publique le 23 mai 1995, le langage et les plateformes Java ont été
marqués par de nombreux événements dont les principaux sont :
[email protected]
COURS Historique EP&TP

10
COURS EP&TP
11
PARTIE 2 :
LES NOTIONS DE BASE
[email protected]
COURS EP&TP
Les concepts de base
[email protected]
12
La plate-forme Java utilise quelques notions de base lors de sa mise en oeuvre, notamment :
•La compilation du code source dans un langage indépendant de la plate-forme d'exécution : le bytecode
•l'exécution du bytecode par une machine virtuelle nommée JVM (Java Virtual Machine)
•la notion de package qui permet d'organiser les classes
•le classpath qui permet de préciser au compilateur et à la JVM où elle peut trouver les classes requises par
l'application
•le packaging des classes compilées dans une archive de déploiement nommée jar (Java ARchive)
Un programme Java est composé d'un ou plus généralement plusieurs fichiers source. N'importe quel éditeur de
texte peut être utilisé pour éditer un fichier source Java.
Ces fichiers source possèdent l'extension .java. Ils peuvent contenir une ou plusieurs classes ou interfaces mais il ne
peut y avoir qu'une seule classe ou interface déclarée publique par fichier. Le nom de ce fichier source doit
obligatoirement correspondre à la casse près au nom de cette entité publique suivi de l'extension .java
Il est nécessaire de compiler le source pour le transformer en J-code ou bytecode Java qui sera lui exécuté par la
machine virtuelle. Pour être compilé, le programme doit être enregistré au format de caractères Unicode : une
conversion automatique est faite par le JDK si nécessaire.
Un compilateur Java, par exemple l'outil javac fourni avec le JDK est utilisé pour compiler chaque fichier source en
fichier de classe possédant l'extension .class. Cette compilation génère pour chaque fichier source un ou plusieurs
fichiers .class qui contiennent du bytecode.
COURS EP&TP
[email protected]
Exécuter un programme Java
13
Pour exécuter une application, la classe servant de point d'entrée doit obligatoirement contenir une
méthode ayant la signature public static void main(String[] args). Il est alors possible de fournir cette classe à
la JVM qui va charger le ou les fichiers .class utiles à l'application et exécuter le code.
1ere méthode sur ligne de commande : 2eme méthode sur ligne de commande :
>javac MaClasse.java >dir *.class
>java MaClasse.java >java MaClasse
COURS EP&TP
[email protected] Hello world :java
14
Java est sensible à la casse.

Les blocs de code sont encadrés par des accolades.
Chaque instruction se termine par un caractère ';'
(point-virgule).
Une instruction peut tenir sur plusieurs lignes :
Pour exécuter le code :

>dir *.class
>java MaClasse
>java MonAutreClasse
COURS EP&TP
[email protected]
Les packages
15 Les fichiers sources peuvent être organisés en packages. Les packages définissent une hiérarchie de noms, chaque
nom étant séparé par le caractère point. Le nom d'un package est lié à une arborescence de sous-répertoires
correspondant à ce nom.
Ceci permet de structurer les sources d'une application car une application peut rapidement contenir plusieurs
centaines voire milliers de fichiers source. Les packages permettent aussi d'assurer l'unicité d'une classe grâce à son
nom pleinement qualifié (nom du package suivi du caractère «.» suivi du nom de la classe).
L'API Java est organisée en packages répartis en trois grands ensembles :
•Packages standards : ce sont les sous-packages du package java
•Packages d'extensions : ce sont les sous-packages du package javax
•Packages tiers : ces packages concernant notamment Corba et XML
Les principaux packages standards de Java 6 sont :
java.applet Création d'applets

java.awt Création d'interfaces graphiques avec AWT
java.io Accès aux flux entrants et sortants
java.lang Classes et interfaces fondamentales
java.math Opérations mathématiques
java.net Accès aux réseaux
java.nio API NIO
java.rmi API RMI (invocation de méthodes distantes)
java.security Mise en oeuvre de fonctionnalités concernant la sécurité
java.sql API JDBC (accès aux bases de données)
java.util Utilitaires (collections, internationalisation, logging, expressions régulières,...).
COURS
[email protected]
Les packages EP&TP
16
Dans le code source, pour éviter d'avoir à utiliser les noms pleinement qualifiés des classes, il
est possible d'utiliser l'instruction import suivi d'un nom de package suivi d'un caractère «.» et
du nom d'une classe ou du caractère «*»
Remarque : par défaut le package java.lang est toujours importé par le compilateur.
COURS EP&TP
[email protected] Les mots réservés du langage Java
17 Java 11 utilise 54 mots réservés qui ne peuvent pas être utilisés comme identifiant.
Les mots réservés (reserved words) peuvent être regroupés en deux catégories :
•51 mots clés (keywords) dont 2 ne sont pas utilisés
•3 valeurs littérales (literals) : true, false et null
Les mots clés sont des mots réservés utilisés dans le code source Java en ayant un rôle particulier
dans la syntaxe du code.
const et goto sont réservés mais ne sont pas utilisés actuellement.
COURS EP&TP
[email protected]
Les identifiants
18 public class MaClasse {
public static void main(String[] args)
{
int valeur = 10;
}
}
Dans l'exemple ci-dessus, plusieurs identifiants sont utilisés dans le code source :
•MaClasse : est le nom d'une classe
•main : est le nom d'une méthode
•String : est le nom d'une classe du JDK
•args : est le nom d'un paramètre
•valeur : est le nom d'une variable locale
Les spécifications de Java imposent des règles strictes pour définir un identifiant valide.
Un identifiant est une séquence d'un ou plusieurs caractères (lettres et chiffres) dont le premier
est obligatoirement une lettre.
Le premier caractère ne peut donc pas être un chiffre.
Les identifiants Java sont sensibles à la casse.

COURS
[email protected] Les identifiants EP&TP
19
Exemple d'identifiants valides :
Exemple d'identifiants invalides :

COURS EP&TP
Les commentaires
[email protected]
20
Ils ne sont pas pris en compte par le compilateur donc ils ne sont pas inclus dans le pseudo code. Ils
ne se terminent pas par un caractère ";".
Il existe trois types de commentaire en Java :
Type de commentaires Exemple
// commentaire sur une seule ligne

commentaire abrégé
int N=1; // déclaration du compteur
commentaire multiligne /* commentaires ligne 1 commentaires ligne 2 */
/**
*commentaire de la méthode
* @param val la valeur à traiter
*@since 1.0
commentaire de documentation automatique
*@return la valeur de retour
* @deprecated Utiliser la nouvelle méthode
*/
COURS EP&TP
[email protected] Les variables
21
Une variable, identifié par un nom, permet d'accéder à une valeur. En Java, une variable est
obligatoirement typée statiquement à sa définition : une fois la variable définie, son type ne peut
pas changer.
Une variable possède un nom, un type et une valeur. La déclaration d'une variable doit donc contenir deux choses :
un nom et le type de données qu'elle peut contenir. Une variable est utilisable dans le bloc où elle est définie.
La déclaration d'une variable permet de réserver la mémoire pour en stocker la valeur.
Le type d'une variable peut être :
•soit un type élémentaire dit aussi type primitif déclaré sous la forme type_élémentaire variable;
•soit une classe déclarée sous la forme classe variable ;
COURS EP&TP
[email protected]
Les types élémentaires
22
Les types élémentaires ont une taille identique quel que soit la plate-forme d'exécution : c'est un des
éléments qui permet à Java d'être indépendant de la plate-forme sur laquelle le code s'exécute.
Les types élémentaires commencent tous par une minuscule.
Type Désignation Longueur Valeurs Commentaires
boolean valeur logique : true ou false 1 bit true ou false pas de conversion possible vers un autre type
byte octet signé 8 bits -128 à 127

short entier court signé 16 bits -32768 à 32767
char caractère Unicode 16 bits \u0000 à \uFFFF entouré de cotes simples dans du code Java
int entier signé 32 bits -2147483648 à 2147483647
float virgule flottante simple précision (IEEE754) 32 bits 1.401e-045 à 3.40282e+038
double virgule flottante double précision (IEEE754) 64 bits 2.22507e-308 à 1.79769e+308
-9223372036854775808 à
long entier long 64 bits
9223372036854775807
COURS
[email protected] Le format des types élémentaires EP&TP
23
Le format des nombres entiers :

Il existe plusieurs formats pour les nombres entiers : les types byte, short, int et long peuvent être codés en décimal,
hexadécimal ou octal. Pour un nombre hexadécimal, il suffit de préfixer sa valeur par 0x. Pour un nombre octal, le
nombre doit commencer par un zéro. Le suffixe l ou L permet de spécifier que c'est un entier long.
Le format des nombres décimaux :
Il existe plusieurs formats pour les nombres décimaux. Les types float et double stockent des nombres flottants : pour
être reconnus comme tels ils doivent posséder soit un point, un exposant ou l'un des suffixes f, F, d, D. Il est possible de
préciser des nombres qui n'ont pas le partie entière ou pas de partie décimale.
Par défaut un littéral représentant une valeur décimale est de type double : pour définir un littéral représentant une
valeur décimale de type float il faut le suffixer par la lettre f ou F.
Type Valeur par défaut

boolean false
byte, short, int, long 0
float, double 0.0
char \u000
classe null
COURS EP&TP
[email protected] L'affectation
24 le signe = est l'opérateur d'affectation et s'utilise avec une expression de la forme variable = expression.
L'opération d'affectation est associative de droite à gauche : il renvoie la valeur affectée ce qui permet d'écrire :
x = y = z = 0;
Opérateur Signification
Exemple
= a=10 équivalent à : a = 10
+= a+=10 équivalent à : a = a + 10
-= a-=10 équivalent à : a = a - 10
*= a*=10 équivalent à : a = a * 10
/= a/=10 équivalent à : a = a / 10
%= a%=10 reste de la division
^= a^=10 équivalent à : a = a ^ 10
équivalent à : a = a << 10 a est complété par des
<<= a<<=10
zéros à droite
équivalent à : a = a >> 10 a est complété par des
>>= a>>=10
zéros à gauche
équivalent à : a = a >>> 10 décalage à gauche non
>>>= a>>>=10
signé
une multiplication d'une variable de type float avec une variable de type double donne un résultat de type
double. Lors d'une opération entre un opérande entier et un flottant, le résultat est du type de l'opérande flottant.
COURS
[email protected]
Les entiers exprimés en binaire EP&TP
25
Avec Java 7, la valeur des types entiers (byte, short, int, et long) peut être exprimée dans le système
binaire en utilisant le préfixe 0b ou 0B
COURS EP&TP
[email protected]
Utilisation des underscores dans les entiers littéraux
26
Il n'est pas facile de lire un nombre qui compte de nombreux chiffres : dès que le nombre de
chiffres dépasse 9 ou 10 la lecture n'est plus triviale, ce qui peut engendrer des erreurs.
A partir de Java 7, il est possible d'utiliser un ou plusieurs caractères tiret bas (underscore) entre les
chiffres qui composent un entier littéral. Ceci permet de faire des groupes de chiffres pour par
exemple séparer les milliers, les millions, les milliards, ... afin d'améliorer la lisibilité du code.
Un nombre quelconque de caractères de

soulignement (underscore) peut apparaître
n'importe où entre les chiffres d'un littéral
numérique. Le caractère underscore doit être
placé uniquement entre deux chiffres. Il n'est
donc pas possible de l'utiliser :
•Au début ou à la fin d'un nombre
•Avant ou après le point de séparation de la
partie décimale d'un nombre flottant
•Avant les suffixes F ou L
COURS EP&TP
[email protected]
Les conversions de types
27
Lors de la déclaration, il est possible d'utiliser un cast :
La conversion peut entrainer Classe Rôle

une perte d'informations.
String pour les chaînes de caractères Unicode
Il n'existe pas en Java de
fonction pour convertir : les Integer pour les valeurs entières (integer)
conversions de type se font Long pour les entiers longs signés (long)
par des méthodes. La Float pour les nombres à virgule flottante (float)
bibliothèque de classes API pour les nombres à virgule flottante en
fournit une série de classes Double
double précision (double)
qui contiennent des
méthodes de manipulation
et de conversion de types
élémentaires.
COURS EP&TP
Les comparaisons
[email protected]
28 Java propose des opérateurs pour toutes les comparaisons :
Opérateur Exemple Signification

> a > 10 strictement supérieur
< a < 10 strictement inférieur
>= a >= 10 supérieur ou égal
<= a <= 10 inférieur ou égal
== a == 10 Egalité
!= a != 10 diffèrent de
& a&b ET binaire
^ a^b OU exclusif binaire
| a|b OU binaire
ET logique (pour expressions booléennes) : l'évaluation de l'expression cesse dès qu'elle

&& a && b
devient fausse
OU logique (pour expressions booléennes) : l'évaluation de l'expression cesse dès qu'elle

|| a || b
devient vraie
opérateur conditionnel : renvoie la valeur b ou c selon l'évaluation de l'expression a (si a

?: a?b:c
alors b sinon c) : b et c doivent retourner le même type
COURS EP&TP
Les opérations arithmétiques
[email protected]
m
29
Les opérateurs arithmétiques se notent + (addition), - (soustraction), * (multiplication), / (division) et
% (reste de la division). Ils peuvent se combiner à l'opérateur d'affectation
Les opérandes et le résultat de l'opération sont convertis en type int. Le résultat est affecté dans un type
short : il y a donc risque de perte d'informations et donc une erreur est émise à la compilation. Cette
promotion évite un débordement de capacité sans que le programmeur soit pleinement conscient du risque
: il est nécessaire, pour régler le problème, d'utiliser une conversion explicite ou cast.
COURS
[email protected]
L'incrémentation et la décrémentationEP&TP
30
Les opérateurs d'incrémentation et de décrémentation sont : n++ ++n n-- --n
Si l'opérateur est placé avant la variable (préfixé), la modification de la valeur est immédiate sinon la modification n'a lieu qu'à
l'issue de l'exécution de la ligne d'instruction (postfixé)
L'opérateur ++ renvoie la valeur avant incrémentation s'il est postfixé, après incrémentation s'il est préfixé.
COURS
[email protected]
La priorité des opérateurs EP&TP
31 Java définit les priorités dans les opérateurs comme suit ( du plus prioritaire au moins prioritaire )
expr++ ==
les opérateurs postfix les opérateurs d'égalité
expr-- !=
l'opérateur OU exclusif ^
++expr
--expr l'opérateur ET &
+expr l'opérateur OU |
les opérateurs unaires
-expr l'opérateur ET logique &&
˜
l'opérateur OU logique ||
!
l'opérateur ternaire ?:
* =
les opérateurs de multiplication, division et
/ +=
modulo
% -=
*=
+
les opérateurs d'addition et soustraction /=
-
les opérateurs d'assignement %=
<< ^=
les opérateurs de décalage >> |=
>>> <<=
>>=
< >>>=
>
l'opérateur arrow ->
les opérateurs de comparaison <=
>=
instanceof
COURS EP&TP
[email protected]
EP01:
32 A.Déclarez une variable entière nommée age et attribuez-lui la valeur de 25. Ensuite, Afficher sa
valeur.
B.Switcher deux variables en utilisant une 3eme variable.
C.Déclarez deux variables entières, a et b. Attribuez à a la valeur 10 et à b la valeur 20.

Échangez les valeurs de a et b sans utiliser une troisième variable, puis afficher les valeurs de a et b.
D.Déclarez une variable pi de type double et attribuez-lui la valeur 3.141592653589793. Ensuite,

imprimez sa valeur avec seulement 2 chiffres après la virgule.
E.Déclarez une variable double nommée nombre avec la valeur 10.5.

Convertissez cette variable en int et imprimez la valeur convertie.
F.Déclarez deux variables entières x et y. Attribuez à x la valeur 15 et à y la valeur 4.

Calculez et imprimez la somme, la différence, le produit, le quotient et le reste de x par rapport à y.
G.Déclarez une variable String nommée phrase avec la valeur "Java est génial !".
Imprimez le nombre de caractères dans la chaîne et le troisième caractère de cette chaîne.
COURS EP&TP
[email protected]
33
PARTIE 3 :
INTRODUIRE LES INTERFACES GRAPHIQUES
COURS EP&TP
[email protected] Exemple interface graphique
34
COURS EP&TP
EP02
35
1.Modification du message de bienvenue:
Modifiez le programme précèdent pour qu'après avoir demandé le nom, l'âge et la taille, il affiche
un seul message sous la forme: "Hello [name], you are [age] years old and [height] cm tall".
2.Vérification de l'âge:
Après avoir demandé l'âge, vérifiez si l'utilisateur est majeur (par exemple, 18 ans ou plus). Si c'est le
cas, affichez "You are an adult", sinon "You are a minor".
3.Calcul de l'IMC:
Après avoir demandé la taille (en cm) et le poids (en kg),
calculez l'indice de masse corporelle (IMC) et affichez-le.
La formule de l'IMC est IMC=poids/taille*taille
[email protected]
COURS EP&TP
[email protected]
36
PARTIE 4 :
LES FONDAMENTEUX DE JAVA
COURS EP&TP
[email protected]
Scanner :lire les données
37
La classe Scanner en Java, provenant du package
java.util,
est un moyen simple et pratique de lire des données
d'entrée depuis la console, un fichier, ou d'autres
sources.
Elle est fréquemment utilisée pour la lecture de
données primitives (comme int, double, etc.) et de
chaînes.
Méthodes de scanner :
•next(): Lit le prochain token/word.
•nextLine(): Lit la ligne complète.
•nextInt(): Lit le prochain token comme un int.
•nextDouble(): Lit le prochain token comme un double.
•nextBoolean(): Lit le prochain token comme un
boolean
COURS EP&TP
[email protected] EP03
38
A.
Écrivez un programme Java qui demande à l'utilisateur de saisir son nom,
puis affiche un message de bienvenue.
B.
Écrivez un programme Java qui demande à l'utilisateur de saisir deux nombres entiers,
puis affiche leur opérations arithmétiques :+ - * / %
C.
Écrivez un programme Java qui demande à l'utilisateur de saisir trois nombres flottants,
puis calcule et affiche leur moyenne.
D.
Demandez à l'utilisateur de saisir trois nombres: a, b, et c.
Calculez et affichez le résultat de a+b×c en respectant la priorité des opérateurs.
COURS EP&TP
[email protected]
Les branchements conditionnels: if ..else
39
'instruction if permet d'exécuter l'instruction ou

le bloc de code qui la suit si l'évaluation de la
condition booléenne est vrai.
Il est possible d'utiliser une instruction
optionnelle else qui précise une instruction ou
un bloc de code à exécuter si l'évaluation de la
condition booléenne est fausse.
COURS EP&TP
[email protected]
Les branchements :Switch
40
L'instruction switch permet d'exécuter du code selon

l'évaluation de la valeur d'une expression. La syntaxe
générale est de la forme :
COURS EP&TP
EP04
[email protected]
41 A.
Écrivez un programme qui demande à l'utilisateur de saisir deux nombres. Le programme doit ensuite
afficher le plus grand des deux nombres.
B.
Demandez à l'utilisateur de saisir un nombre. Vérifiez si ce nombre est à la fois positif et pair, puis affichez le résultat.
C.
Créer un programme simple qui simule un jeu.
Lorsque l'utilisateur exécute le programme, il est informé qu'il peut quitter le jeu à tout moment en appuyant sur "q" ou "Q".
1.Demandez à l'utilisateur d'entrer une réponse.
2.Si l'utilisateur entre une réponse différente de "q" ou "Q", affichez le message : "Vous continuez à jouer au jeu pew pew".
3.Si l'utilisateur entre "q" ou "Q", affichez le message : "Vous avez quitté le jeu".
D.
Écrivez un programme qui demande à l'utilisateur d'entrer une note alphabétique (A, B, C, D, E,F).
Affichez un message correspondant à la performance de l'étudiant.(Excellent ,Très bien ,Bien ,Assez bien ,Passable,Faible)
E.
Écrivez un programme qui demande à l'utilisateur d'entrer un nom de mois. Affichez le nombre de jours de ce mois.
Ignorez les années bissextiles.
COURS EP&TP
[email protected]
Les boucles
42 Java propose plusieurs types de boucles :
•while(condition)
•do ... while(condition)
•for
•for évolué (depuis Java 1.5)
Une boucle while() permet d'exécuter l'instruction ou le bloc de code qui la suit tant que la condition booléenne est
évaluée à vrai. La condition est évaluée en début de chaque itération. La syntaxe générale est de la forme :
while ( boolean ) { // code à exécuter dans la boucle }
Si avant l'instruction while, le booléen est faux, alors le code de la boucle ne sera jamais exécuté.
Ne pas mettre de ; après la condition sinon le corps de la boucle ne sera jamais exécuté.
Une boucle do ... while() permet d'exécuter l'instruction ou le bloc de code qui la suit tant que la condition booléenne
est évaluée à vrai. La condition est évaluée en fin de chaque itération. La syntaxe générale est de la forme :
Cette boucle est au moins exécutée une fois quelle que soit la valeur du booléen.
do { // ... } while ( boolean );

La boucle for permet de réaliser une boucle dont la définition est composée de plusieurs parties optionnelles. La syntaxe générale
est :
for ( initialisation; condition; modification ) { ... }
COURS EP&TP
[email protected] Boucle For
43
Java 1.5 propose une nouvelle syntaxe pour les boucles

for : les boucles for évoluées pour faciliter le parcours
intégral des Iterator et des tableaux.
L'itération sur les éléments d'une collection est
verbeuseuse avec la déclaration d'un objet de type
Iterator.
COURS EP&TP
[email protected]
Boucle For
44 La nouvelle forme de l'instruction for, spécifiée dans la JSR 201, permet de simplifier l'écriture du
code pour réaliser une telle itération et laisse le soin au compilateur de générer le code
nécessaire
L'utilisation de la syntaxe de l'instruction for évouée peut

être renforcée en combinaison avec les generics, ce qui
évite l'utilisation d'un cast.
Les débranchements :Break et continue
COURS EP&TP
[email protected]
45
L'instruction break permet de quitter immédiatement une boucle ou un branchement. Elle est
utilisable dans tous les contrôles de flot.
L'instruction continue s'utilise dans une boucle pour passer directement à l'itération suivante
break et continue peuvent s'exécuter avec des blocs nommés.
Il est possible de préciser une étiquette pour indiquer le point de retour lors de la fin du traitement
déclenché par le break.
Une étiquette est un nom suivi d'un caractère deux-points qui définit le début d'une instruction.
label1: label2:
for (int i = 0; i < 3; i++) for (int i = 0; i < 3; i++) {
{ for (int j = 0; j < 3; j++) {
for (int j = 0; j < 3; j++) { if (i == 1 && j == 1) {
if (i == 1 && j == 1) { continue label2;
break label1; }
} System.out.println("i: " + i + ", j: " + j);
System.out.println("i: " + i + ", j: " + j); }
} }
}
COURS EP&TP
EP05
m
46
[email protected]
A. Créez une boucle qui affiche les 5 premiers nombres entiers en utilisant l'incrémentation.
B. Créez une boucle qui affiche les nombres de 5 à 1 en utilisant la décrémentation.
C.Écrivez un programme qui utilise une boucle while pour afficher les nombres pairs de 2 à 20.
D.Écrivez un programme qui demande à l'utilisateur de saisir un nombre positif.

Si l'utilisateur saisit un nombre négatif, le programme doit continuer à lui demander un nombre positif jusqu'à ce qu’il
entre un positif . Utilisez une boucle do-while.
E.Écrivez un programme qui utilise des boucles imbriquées pour afficher les tables de multiplication de 1 à 5.
F.Écrivez un programme qui utilise une boucle pour afficher les nombres de 1 à 30,
mais qui s'arrête et sort de la boucle lorsque le nombre 20 est atteint.
G.Écrivez un programme Écrivez un programme

qui utilise deux bouclesqui affiche lespour
imbriquées nombres de les
afficher 1 à coordonnées
10 sauf 3,6, et(i,9j)
pour i allant de 1 à 5 et j allant de 1 à 5. Si j=3, utilisez continue pour sauter à la prochaine itération de la boucle interne.
Si i=4, utilisez une étiquette et break pour sortir de la boucle externe.
COURS EP&TP
EP06
47
A
1.Écrire un programme calculant la somme des n premiers termes de la "série harmonique",
c’est-à-dire la somme :
1 + 1/2 + 1/3 + 1/4 + ..... + 1/n
La valeur de n sera lue en donnée.
2.Améliorer le programme précédant afin de lire l'entier n, lors de l'exécution du programme.
B. Combien de lignes ? 5
Écrire un programme qui affiche un triangle isocèle formé
*
d’étoiles.
***
La hauteur du triangle (c’est-à-dire son nombre de lignes)
*****
sera fourni en donnée, comme dans
*******
l’exemple ci-dessous.
*********
On s’arrangera pour que la dernière ligne du triangle
s’affiche sur le bord gauche de l’écran.
[email protected]
COURS EP&TP
Strings
48
Une chaîne de caractères en Java, encapsulée dans une instance de type java.lang.String
est immutable : elle ne peut pas être modifiée. Le résultat d'une action de modification
créé une nouvelle chaîne qui contient le résultat de la modification et laisse la chaîne
initiale dans le même état.
Chaque traitement qui vise à transformer une instance de la classe est implémentée par
une méthode qui laisse l'objet d'origine inchangé et renvoie une nouvelle instance de
String contenant les modifications.
Il est ainsi possible d'enchaîner plusieurs méthodes :
[email protected]
COURS EP&TP
Strings
49
les variables de type String sont des objets. Partout où des constantes chaînes de caractères figurent entre
guillemets, le compilateur Java génère un objet de type String avec le contenu spécifié. Il est donc possible d'écrire :
Il est donc important d'utiliser la chaîne retournée par ces méthodes. Il est par exemple possible d'affecter le
résultat de ces méthodes à la variable pour qu'elle pointe sur la nouvelle chaîne de caractères contenant les
modifications ou sur une autre variable pour pouvoir conserver une référence sur l'originale.
[email protected]
[email protected] Blocs de textes
50
La syntaxe est proche de celle utilisée par Python.
Un bloc de texte peut contenir zéro ou plusieurs caractères
entourés par un délimiteur de début et de fin. La syntaxe
repose sur deux délimiteurs particuliers distincts :
•délimiteur de début : trois double quotes """ et un retour
chariot qui est obligatoire
•délimiteur de fin : trois double quotes """
L'utilisation de trois doubles quotes d'affilés comme
délimiteur a été choisie pour facilement l'identification d'un
bloc de texte.
Les blocs de texte débutent par un délimiteur de début qui
est composé de plusieurs éléments :
•3 caractères double quotes qui se suivent : """
•zéro ou plusieurs caractères espaces
•un retour chariot
COURS EP&TP
COURS EP&TP
Les méthodes des Strings
51
[email protected]
COURS EP&TP
52
[email protected]
COURS EP&TP
53
[email protected]
COURS EP&TP
54
[email protected]
COURS EP&TP
55
[email protected]
COURS EP&TP
56
[email protected]
COURS EP&TP
57
[email protected]
COURS EP&TP
[email protected]
58
COURS EP&TP
59
[email protected]
COURS EP&TP
60
[email protected]
COURS EP&TP
61
[email protected]
COURS Exemples méthodes EP&TP
62
[email protected]
[email protected]
63
[email protected]
64
COURS EP&TP
Exemples méthodes
[email protected]
65
[email protected]
66
COURS EP&TP
[email protected]
Exemples méthodes
67
[email protected]
68
COURS EP&TP
[email protected]
StringBuilder
69
La classe StringBuilder en Java est une classe mutable qui permet de manipuler et de construire des chaînes de
caractères de manière efficace.
Elle est particulièrement utile lorsque vous devez effectuer de nombreuses modifications sur une chaîne, car elle
évite la création de nombreux objets String intermédiaires.
Voici quelques points clés concernant StringBuilder:
1.Mutable: Contrairement à String qui est immuable, StringBuilder peut être modifié après sa création.
2.Performance: L'utilisation de StringBuilder peut être plus rapide que l'utilisation de String pour des opérations
répétées, car il évite la création de nombreux objets String intermédiaires.
3.Méthodes courantes:
•append(...): Ajoute des données à la fin du contenu
actuel.
•insert(int offset, ...): Insère des données à un indice
spécifié.
•delete(int start, int end): Supprime une sous-chaîne.
•reverse(): Inverse le contenu.
•toString(): Convertit le contenu en String.
StringBuilder en String pour l'affichage

COURS EP&TP
70 A.Écrivez une méthode qui prend une chaîne en paramètre et renvoie la même chaîne, mais avec la
première lettre en majuscule
B.Écrivez une méthode qui prend une chaîne en paramètre et renvoie le nombre d'occurrences
du mot "java" (indépendamment de la casse).
C.Écrivez une méthode qui retourne le mot le plus long d'une chaîne donnée.
D.Écrivez une méthode qui prend une chaîne en paramètre et retourne cette chaîne avec toutes les voyelles
supprimées.
E.Écrivez une méthode qui prend en paramètre une chaîne et renvoie cette chaîne inversée.
F.Écrivez une méthode qui compte le nombre de mots dans une chaîne donnée.
G.Écrivez une méthode qui remplace chaque espace d'une chaîne par un tiret ("-").
H.Écrivez une méthode qui vérifie si une chaîne contient uniquement des chiffres.
I.Écrivez une méthode qui prend en paramètre une chaîne et renvoie cette chaîne, mais
avec chaque mot commencant et finissant par une lettre majuscule.
COURS Les méthodes mathématiques EP&TP
71
[email protected]
La classe java.lang.Math contient une série de méthodes et variables mathématiques. Comme la classe Math
fait partie du package java.lang, elle est automatiquement importée. De plus, il n'est pas nécessaire de
déclarer un objet de type Math car les méthodes sont toutes static.
COURS EP&TP
Méthodes mathématiques
72
COURS EP&TP
Classe BigDecimal
[email protected]
Cependant certains calculs, notamment ceux relatifs à des aspects financiers par exemple,
73 requièrent une précision particulière : ces calculs utilisent généralement une précision de deux
chiffres.
La classe BigDecimal permet de réaliser de tels calculs en permettant d'avoir le contrôle sur la
précision (nombre de décimales significatives après la virgule) et la façon dont l'arrondi est
réalisé.
COURS EP&TP
Randoms
74
[email protected]
COURS Gestion des exceptions EP&TP
75
[email protected]
Les exceptions représentent le mécanisme de gestion des erreurs intégré au langage Java. Il se compose d'objets
représentant les erreurs et d'un ensemble de trois mots clés qui permettent de détecter et de traiter ces erreurs
(try, catch et finally ) mais aussi de les lever ou les propager (throw et throws).
Lors de la détection d'une erreur, un objet qui hérite de la classe Exception est créé (on dit qu'une exception est
levée) et propagé à travers la pile d'exécution jusqu'à ce qu'il soit traité.
Ces mécanismes permettent de renforcer la sécurité du code Java.
COURS
Gestion des exceptions: classe Throwable EP&TP
76
[email protected]
Cette classe descend directement de la classe Object : c'est la classe de base pour le traitement des erreurs.
Cette classe possède deux constructeurs :
Méthode Rôle
Throwable()
La chaîne en paramètre permet de définir un
Throwable(String) message qui décrit l'exception et qui pourra être
consulté dans un bloc catch.
Les principales méthodes de la classe Throwable sont :
Méthodes Rôle
String getMessage( ) lecture du message
affiche l'exception et l'état de la pile
void printStackTrace( )
d'exécution au moment de son appel
void printStackTrace(PrintStream s) Idem mais envoie le résultat dans un flux
COURS Gestion des exceptions: classe Throwable EP&TP
77
[email protected]
COURS EP&TP
Les exceptions personnalisées
78 Pour générer une exception, il suffit d'utiliser le mot clé throw, suivi d'un objet dont la classe dérive de
Throwable. Si l'on veut générer une exception dans une méthode avec throw, il faut l'indiquer dans la
déclaration de la méthode, en utilisant le mot clé throws.
En cas de nécessité, on peut créer ses propres exceptions. Elles descendent des classes Exception ou
RunTimeException mais pas de la classe Error. Il est préférable (par convention) d'inclure le mot «
Exception » dans le nom de la nouvelle classe.
[email protected]
COURS EP08 EP&TP
[email protected] A.Écrivez une méthode pour trouver le plus grand commun diviseur (PGCD) de deux nombres.
79
B.Écrivez une méthode pour vérifier si un nombre est premier ou non.
C.Écrivez une méthode pour inverser un nombre (par exemple, 1234 devient 4321).
D.Écrivez une méthode pour calculer la somme des chiffres d'un nombre.
E.Calculer la longueur d’un coté de triangle en utilisant théorie de Vitagorsse.Les entrées A et B ?
F.Écrivez une méthode qui prend en paramètre un rayon et renvoie la surface et le volume d'une sphère.
G.Écrivez une méthode qui prend deux nombres en paramètres et effectue une division. La méthode doit lancer une
exception si le dénominateur est zéro.
H.Écrivez une méthode qui génère un nombre aléatoire entre 1 et 10, prend la racine carrée de ce nombre,
puis renvoie le résultat. Si le nombre généré est 1, lancez une exception indiquant que "1 is not a valid
random number".
I.Écrivez une méthode qui convertit une chaîne en entier. Attrapez et traitez l'exception lorsque la chaîne n'est pas
un nombre valide.
COURS EP&TP
[email protected]
Les tableaux
80 Les tableaux permettent de stocker un ensemble fini d'éléments d'un type particulier. L'accès à un
élément particulier se fait grâce à son indice. Le premier élément d'un tableau possède l'indice 0.
Même si leur déclaration est spécifique, ce sont des objets : ils sont donc dérivés de la classe
Object. Il est possible d'utiliser les méthodes héritées telles que equals() ou getClass().
La déclaration d'un tableau à une dimension requiert un type, le nom de la variable permettant de faire référence au
tableau et une paire de crochets. Java permet de placer les crochets sur le type ou sur le nom de la variable dans la
déclaration.
L'allocation de la mémoire et donc l'obtention d'une référence pour accéder au tableau se fait en utilisation
l'opérateur new, suivi d'une paire de crochets qui doit contenir le nombre maximum d'éléments que peut contenir
le tableau.
La déclaration et l'allocation peut se faire sur une même ligne ou sur des lignes distinctes.
COURS EP&TP
[email protected]
Les tableaux
81
Pour passer un tableau à une méthode, il suffit de déclarer
le paramètre dans la signature de la méthode
Tableau multi-dimenssiels
L'initialisation explicite d'un tableau

COURS EP&TP
Parcourir les tableaux
82
La variable length retourne le nombre d'éléments du tableau. Il est alors possible d'utiliser une
boucle pour itérer sur chacun des éléments du tableau.
[email protected]
COURS EP&TP
[email protected]
EP09
83
A.
Écrire un programme permettant de remplir un tableau de 5 éléments, ensuite, afficher
tous les éléments du tableau .
calculer et afficher la somme , la moyenne des éléments de ce tableau.
B.Écrivez un programme qui trouve et affiche le plus grand élément et le petit d'un tableau d'entiers.
C.Écrivez un programme qui inverse le contenu d'un tableau d'entiers.
D.Écrire un programme qui crée un tableau comportant les valeurs des carrés des n premiers
nombres impairs, la valeur de n étant lue au clavier et qui en affiche les valeurs
E.Écrivez un programme qui crée un nouveau tableau en supprimant un élément spécifique d'un tableau d'entiers.
F.Déclarer les deux tableaux suivants en Java :

Créer une fonction permettant d’afficher les éléments
de chaque tableau ligne par ligne.
COURS EP&TP
ArrayList
[email protected]
84 •ArrayList :Type de liste est une implémentation dynamique basée sur un tableau.
•Permet un accès rapide aux éléments par leur indice (O(1)).
•Convient pour les opérations fréquentes de lecture et d'accès, mais moins efficace pour l'insertion et la
suppression d'éléments au milieu de la liste.
les méthodes des listes spécifiques offrent des opérations

supplémentaires :
•add(E element) : Ajoute un élément à la fin de la liste.
•add(int index, E element) : Insère un élément à l'index spécifié
dans la liste.
•remove(Object o) : Supprime la première occurrence de l'élément
spécifié de la liste.
•remove(int index) : Supprime l'élément à l'index spécifié dans la
liste.
•get(int index) : Récupère l'élément à l'index spécifié dans la liste.
•set(int index, E element) : Remplace l'élément à l'index spécifié
par un nouvel
COURS EP&TP
Java.util.Arrays
85
[email protected]
La classe java.util.Arrays fait partie de la bibliothèque standard Java et fournit des méthodes utilitaires
pour manipuler des tableaux.
Cette classe contient des méthodes statiques pour trier, rechercher, comparer, copier et remplir des
tableaux.
COURS EP&TP
[email protected]
Arrays.asList()
La méthode statique Arrays.asList() est une méthode très utile fournie par la classe utilitaire Arrays de Java.
86
Elle permet de créer une liste fixe à partir d'un tableau ou d'une série d'éléments.
La liste renvoyée par Arrays.asList() est de taille fixe. Cela signifie que vous ne pouvez ni ajouter ni supprimer
des éléments.
Si vous essayez de le faire, une UnsupportedOperationException sera levée. Cependant, vous pouvez modifier
un élément (opération set).
utile pour créer rapidement des listes pour des opérations
temporaires, des tests ou des scénarios où une liste fixe La liste renvoyée par Arrays.asList() est
une vue sous-jacente du tableau fourni.
Ainsi, si vous modifiez le tableau
Vous pouvez créer une liste à partir d'un original, les modifications se
tableau ou directement à partir d'arguments. refléteront dans la liste, et vice-versa.
String[] array = {"X", "Y", "Z"};
String[] arrayOfStrings = {"A", "B", "C"};
List<String> listFromArr =
List<String> listOfStrings =
Arrays.asList(array);
Arrays.asList(arrayOfStrings);
array[0] = "A";
System.out.println(listFromArr.get(0)); //
// Ou directement à partir d'arguments
Affichera "A"
List<Integer> listOfIntegers =
Arrays.asList(1, 2, 3, 4, 5);
listFromArr.set(1, "B");
System.out.println(array[1]); // Affichera "B"
COURS EP&TP
EP10
87
B:
A:
Vous gérez une petite bibliothèque. Écrivez un programme pour :
1. Créer une ArrayList 1.Créer une liste de livres (titre des livres).
2. -Ajouter des numéros à la liste 2.Ajouter quelques titres de livres à la liste.
3. -Calculer la somme des éléments d'une 3.Afficher le troisième livre de la liste.
liste 4.Mettre à jour le premier livre par un nouveau titre.
4. -Trouver les nombres pairs dans la liste 5.Supprimer le dernier livre de la liste.
5. -Trouver le plus grand élément dans la liste 6.Parcourir et afficher tous les titres de livres dans la liste.
6. -Créer une liste de nombres premiers 7.Trier la liste par ordre alphabétique.
7. -Créer une autre liste contenant des lettres 8.Vérifier si le livre « Flutter » est dans la liste.
9.Afficher la taille de la liste.
8. -Trier la liste de chaînes de caractères
10.Vider la liste et vérifier si elle est vide.
9. Fusionner les 2 listes
C:
Convertir un tableau de chaînes en une liste et ajouter un nouvel élément à cette liste.
D:
[email protected]
Convertir une List<String> en un tableau String[].
COURS EP&TP
[email protected]
TP01 :Gestionnaire de notes des étudiants
88
1. Demandez à l'utilisateur combien d'étudiants il souhaite ajouter.

2. Créez un tableau pour stocker les noms des étudiants.
3. Créez un autre tableau pour stocker leurs notes.
4. Utilisez une boucle pour saisir les noms et les notes des étudiants. Assurez-vous que les notes sont des
valeurs valides (entre 0 et 20).
5. Calculez et affichez la moyenne de la classe.
6. Utilisez une boucle et des conditions pour afficher les noms des étudiants ayant des notes supérieures à
la moyenne.
7. Demandez à l'utilisateur le nom d'un étudiant.
8. Cherchez et affichez la note de cet étudiant ou un message d'erreur si l'étudiant n'est pas trouvé.
9. Demandez à l'utilisateur le nom d'un étudiant.
10.Si l'étudiant est trouvé, demandez une nouvelle note et mettez à jour le tableau de notes.
11.Ajoutez une option pour permettre à l'utilisateur de supprimer un étudiant et sa note.
12.Utilisez un tableau multidimensionnel pour stocker les noms et les notes des étudiants.
13.Ajoutez une fonctionnalité pour trier les étudiants par nom ou par note.
COURS EP&TP
[email protected]
TAF01:
89
 Réaliser le TP01 précèdent en utilisant les interfaces graphiques swing .
 Exemple du résultat ;
 Créer un nouveau projet JAVA qui permet de Réaliser le même TP01 précèdent en
utilisant cette fois les interfaces graphiques swing et Mysql.
 Installer le jar de MYSQL dans le projet : https://downloads.mysql.com/archives/c-j/
 Utiliser phpmyadmin de Xampp comme SGBD
 La base de donnée contient seulement une table etudiants (id,non,note)
COURS EP&TP
[email protected]
90
PARTIE 5:
PROGRAMMATION ORIENTE OBJET
COURS EP&TP
POO
91 Le concept de classe
➢ Une classe est le support de l'encapsulation : c'est un

ensemble de données et de fonctions regroupées
dans une même entité.
➢ Une classe est une description abstraite d'un objet.
La syntaxe de déclaration d'une classe est la suivante
➢ Les fonctions qui opèrent sur les données sont
:
appelées des méthodes.
modificateurs class nom_de_classe [extends
➢ Instancier une classe consiste à créer un objet sur son
classe_mere] [implements interfaces]
modèle.
{ ... }
➢ Entre classe et objet il y a, en quelque sorte, le même
rapport qu'entre type et variable.
➢ Java est un langage orienté objet : tout appartient à
une classe sauf les variables de types primitives.
➢ Pour accéder à une classe il faut en déclarer une public class Voiture extends Vehicule
instance de classe ou objet. implements Roulant
➢ Une classe comporte sa déclaration, des variables et {
les définitions de ses méthodes. }
[email protected]
COURS EP&TP
[email protected] Modificateurs
92
Modificateur Rôle
la classe contient une ou des méthodes abstraites, qui n'ont pas de

définition explicite. Une classe déclarée abstract ne peut pas être instanciée
abstract
: il faut définir une classe qui hérite de cette classe et qui implémente les
méthodes nécessaires pour ne plus être abstraite.
la classe ne peut pas être modifiée, sa redéfinition grâce à l'héritage est

final interdite. Les classes déclarées final ne peuvent donc pas avoir de classes
filles.
private la classe n'est accessible qu'à partir du fichier où elle est définie
Si une méthode ou une variable est déclarée protected, seules les

méthodes présentes dans le même package que cette classe ou ses
protected
sous-classes pourront y accéder. On ne peut pas qualifier une
classe avec protected.
COURS EP&TP
[email protected]
Objet/classe
93
➢ Les objets contiennent des attributs et des méthodes.

➢ Les attributs sont des variables ou des objets nécessaires au fonctionnement de l'objet.
➢ En Java, une application est un objet.
➢ La classe est la description d'un objet.
➢ Un objet est une instance d'une classe.
➢ Pour chaque instance d'une classe, le code est le même, seules les données sont différentes à
chaque objet.
L'opérateur new se charge de créer une instance de la classe et de l'associer à la variable

COURS EP&TP
Les références et la comparaison d'objets
[email protected]
94
Les variables de type objet que l'on déclare ne contiennent pas un objet mais une référence vers cet objet. Lorsque
l'on écrit c1 = c2 (c1 et c2 sont des objets), on copie la référence de l'objet c2 dans c1. c1 et c2 font référence au
même objet : ils pointent sur le même objet. L'opérateur == compare ces références. Deux objets avec des
propriétés identiques sont deux objets distincts
Pour comparer l'égalité des variables de deux instances, il faut munir la classe d'une méthode à cet effet : la
méthode equals() héritée de Object.
Pour s'assurer que deux objets sont de la même classe, il faut utiliser la méthode getClass() de la classe Object dont
toutes les classes héritent.
COURS EP&TP
[email protected] Les variables de classes
95
Elles ne sont définies qu'une seule fois quel que soit le
nombre d'objets instanciés de la classe. Leur déclaration
est accompagnée du mot clé static
L'appartenance des variables de classe à une classe entière
et non à un objet spécifique permet de remplacer le nom
de la variable par le nom de la classe.
La variable this
L'opérateur instanceof permet de

déterminer la classe de l'objet qui
lui est passé en paramètre. La
syntaxe est objet instanceof classe
COURS EP&TP
[email protected] Le mot clé static
96
Le mot clé static s'applique aux variables et aux méthodes.
Les variables d'instance sont des variables propres à un objet. Il est possible de définir une variable de
classe qui est partagée entre toutes les instances d'une même classe : elle n'existe donc qu'une seule
fois en mémoire. Une telle variable permet de stocker une constante ou une valeur modifiée tour à tour
par les instances de la classe. Elle se définit avec le mot clé static.
Il est aussi possible par exemple de mémoriser les valeurs min et max d'un ensemble d'objets de même classe.
Une méthode static est une méthode qui n'agit pas sur des variables d'instance mais uniquement sur des variables
de classe. Ces méthodes peuvent être utilisées sans instancier un objet de la classe. Les méthodes ainsi définies
peuvent être appelées avec la notation classe.methode() au lieu de objet.methode() : la première forme est
fortement recommandée pour éviter toute confusion.
Il n'est pas possible d'appeler une méthode d'instance ou d'accéder à une variable d'instance à partir d'une
méthode de classe statique
COURS EP&TP
[email protected]
Le mot clé final
97
Le mot clé final s'applique aux variables de classe ou d'instance ou locales, aux méthodes, aux paramètres d'une
méthode et aux classes. Il permet de rendre l'entité sur laquelle il s'applique non modifiable une fois qu'elle est
déclarée pour une méthode ou une classe et initialisée pour une variable.
Une variable qualifiée de final signifie que la valeur de la variable ne peut plus être modifiée une fois que celle-
ci est initialisée.
Une fois la variable déclarée final initialisée, il n'est plus possible de modifier sa valeur. Une vérification est
opérée par le compilateur.
COURS EP&TP
[email protected] Le mot clé abstract
Le mot clé abstract s'applique aux méthodes et aux classes.
98 Abstract indique que la classe ne pourra être instanciée telle quelle. De plus, toutes les méthodes de
cette classe abstract ne sont pas implémentées et devront être redéfinies par des méthodes
complètes dans ses sous-classes.
Abstract permet de créer une classe qui sera une sorte de moule. Toutes les classes dérivées
pourront profiter des méthodes héritées et n'auront à implémenter que les méthodes déclarées
abstract.
Une méthode abstraite est une méthode déclarée avec le modificateur abstract et sans corps. Elle
correspond à une méthode dont on veut forcer l'implémentation dans une sous-classe. L'abstraction permet
une validation du codage : une sous-classe sans le modificateur abstract et sans définition explicite d'une ou
des méthodes abstraites génère une erreur de compilation.
Une classe est automatiquement abstraite dès qu'une de ses méthodes est déclarée abstraite. Il est possible
de définir une classe abstraite sans méthodes abstraites.
COURS EP&TP
[email protected]
Méthodes
99 Sans modificateur, la méthode peut être appelée par toutes autres méthodes des classes du
package auquel appartient la classe.
La valeur de retour de la méthode doit être transmise par l'instruction return. Elle indique la
valeur que prend la méthode et termine celle-ci : toutes les instructions qui suivent return sont
donc ignorées.
les varargs permettent de passer un nombre non défini

d'arguments d'un même type à une méthode. Ceci va
éviter de devoir encapsuler ces données dans une
collection.
Elle utilise un notation pour préciser la répétition d'un
type d'argument utilisant trois petits points : ...
COURS EP&TP
[email protected] La surcharge de méthodes
100
La surcharge d'une méthode permet de définir plusieurs fois une même méthode avec des arguments
différents.
Le compilateur choisi la méthode qui doit être appelée en fonction du nombre et du type des
arguments. Ceci permet de simplifier l'interface des classes vis à vis des autres classes.
Une méthode est surchargée lorsqu'elle exécute des actions différentes selon le type et le nombre de
paramètres transmis.
Il est donc possible de donner le même nom à deux méthodes différentes à condition que les
signatures de ces deux méthodes soient différentes. La signature d'une méthode comprend le nom
de la classe, le nom de la méthode et les types des paramètres.
Il n'est pas possible d'avoir deux méthodes de même
nom dont tous les paramètres sont identiques et
dont seul le type retourné diffère.
COURS EP&TP
[email protected] Constructeurs
101 La déclaration d'un objet est suivie d'une sorte d'initialisation par le moyen d'une méthode
particulière appelée constructeur pour que les variables aient une valeur de départ .
La définition d'un constructeur est facultative.

Si aucun constructeur n'est explicitement
défini dans la classe, le compilateur va créer
un constructeur par défaut sans argument.
Dès qu'un constructeur est explicitement
défini, le compilateur considère que le
programmeur prend en charge la création des
constructeurs et que le mécanisme par défaut,
qui correspond à un constructeur sans
paramètres, n'est pas mis en oeuvre. Si on
souhaite maintenir ce mécanisme, il faut
définir explicitement un constructeur sans
paramètres en plus des autres constructeurs.
COURS EP&TP
[email protected] Les accesseurs
102 L'encapsulation permet de sécuriser l'accès aux données d'une classe. Ainsi, les données déclarées
private à l'intérieur d'une classe ne peuvent être accédées et modifiées que par des méthodes
définies dans la même classe. Si une autre classe veut accéder aux données de la classe, l'opération
n'est possible que par l'intermédiaire d'une méthode de la classe prévue à cet effet. Ces appels de
méthodes sont appelés « échanges de messages ».
Un accesseur est une méthode publique qui donne l'accès à une variable d'instance privée. Pour une
variable d'instance, il peut ne pas y avoir d'accesseur, un seul accesseur en lecture ou un accesseur
en lecture et un autre en écriture. Par convention, les accesseurs en lecture commencent par get et
les accesseurs en écriture commencent par set.
Pour un attribut de type booléen, il est possible de faire

commencer l'accesseur en lecture par is au lieu de get.
COURS EP&TP
[email protected]
Héritage
103 L'héritage est un mécanisme qui facilite la réutilisation du code et la gestion de son évolution. Elle
définit une relation entre deux classes :
•une classe mère ou super-classe
•une classe fille ou sous-classe qui hérite de sa classe mère
Grâce à l'héritage, les objets d'une classe fille ont accès aux données et aux méthodes de la classe parente et
peuvent les étendre. Les sous-classes peuvent redéfinir les variables et les méthodes héritées. Pour les variables, il
suffit de les redéclarer sous le même nom avec un type différent. Les méthodes sont redéfinies avec le même nom,
les mêmes types et le même nombre d'arguments, sinon il s'agit d'une surcharge.
Object est la classe parente de toutes les classes en Java. Toutes les variables et méthodes contenues dans
Object sont accessibles à partir de n'importe quelle classe car par héritages successifs toutes les classes
héritent d'Object.
On utilise le mot clé extends pour indiquer qu'une classe hérite d'une autre. En l'absence de ce mot réservé associé
à une classe, le compilateur considère la classe Object comme classe mère.
Pour invoquer une méthode d'une classe mère, il suffit d'indiquer la méthode préfixée par super. Pour appeler
le constructeur de la classe mère, il suffit d'écrire super(paramètres) avec les paramètres adéquats.
Le lien entre une classe fille et une classe mère est géré par la plate-forme : une évolution des règles de gestion
de la classe mère conduit à modifier automatiquement la classe fille dès que cette dernière est recompilée.
En Java, il est obligatoire dans un constructeur d'une classe fille de faire appel explicitement ou implicitement
au constructeur de la classe mère
COURS EP&TP
[email protected]
Héritage: exemple
104
COURS
[email protected]
Polymorphisme – Redéfinition -Surcharge EP&TP
Le polymorphisme est la capacité, pour un même message de correspondre à plusieurs formes de

105
traitements selon l'objet auquel ce message est adressé. La gestion du polymorphisme est assurée
par la machine virtuelle dynamiquement à l'exécution.
La redéfinition (overriding) est une fonctionnalité qui permet de mettre en ouvre une forme de polymorphisme.
Une sous-classe fournit une implémentation dédiée d'une méthode héritée de sa super-classe : les signatures des
deux méthodes doivent être les mêmes. Le choix de la méthode à exécuter est déterminé à l'exécution en fonction du
type de l'objet qui l'invoque.
La redéfinition d'une méthode héritée doit impérativement conserver la déclaration de la méthode parente (type et
nombre de paramètres, la valeur de retour et les exceptions propagées doivent être identiques).
Si la signature de la méthode change, ce n'est plus une redéfinition mais une surcharge.
La surcharge (overload) est une fonctionnalité qui permet

de mettre en oeuvre une forme de polymorphisme. Elle
permet de définir différentes méthodes ayant le même nom
avec le nombre et/ou le type des paramètres différent.
Le choix de la méthode à exécuter est déterminée
statiquement par le compilateur en fonction des paramètres
utilisés à l'invocation.
COURS EP&TP
[email protected] Polymorphisme :exemple
106
Dans cet exemple, nous avons une classe abstraite Forme avec une méthode abstraite dessiner(). Trois classes, Cercle,
Rectangle et Triangle, héritent de Forme et implémentent la méthode dessiner() de manière spécifique.
Dans la méthode main(), nous créons des objets de type Forme en utilisant des instances des classes dérivées (Cercle,
Rectangle et Triangle). Ces objets sont déclarés avec le type Forme, ce qui permet le polymorphisme.
COURS EP&TP
[email protected]
Les interfaces et l'héritage multiple
107
Avec l'héritage multiple, une classe peut hériter en même temps de plusieurs super-classes.
Ce mécanisme n'existe pas en Java. Les interfaces permettent de mettre en oeuvre un mécanisme
de remplacement.
Une interface est un ensemble de constantes et de

déclarations de méthodes correspondant un peu à une classe
abstraite.
Plusieurs interfaces peuvent être implémentées dans une
même classe.
Les interfaces se
déclarent avec le
mot clé interface
et sont intégrées
aux autres
classes avec le
mot clé
implements
Toutes les méthodes d'une interface sont abstraites.

COURS EP&TP
[email protected]
Interfaces: Les méthodes par défaut
108 A partir de Java 8, il est possible d'utiliser les méthodes par défaut (default method) dans une
interface. Elles permettent de définir le comportement d'une méthode dans l'interface dans laquelle
elle est définie. Si aucune implémentation de la méthode n'est fournie dans une classe qui
implémente l'interface alors c'est le comportement défini dans l'interface qui sera utilisé.
Les méthodes par défaut sont virtuelles comme toutes les

autres méthodes mais elles proposent une implémentation
par défaut qui sera invoquée si la classe implémentant
l'interface ne redéfinit pas explicitement la méthode.
Une classe qui implémente une interface n'a donc pas
l'obligation de redéfinir une méthode par défaut. Si celle-ci
n'est pas redéfinie alors c'est l'implémentation contenue
dans l'interface qui est utilisée.
COURS EP&TP
[email protected]
Interfaces locales
109
Java 16 permet de définir des interfaces locales, qui ne pourront donc être utilisées que dans la
classe où elles sont définies.
COURS EP&TP
Annotations
110
Les annotations fournissent des informations sur des entités : elles n'ont pas d'effets directs sur les entités qu'elles
concernent.
Les annotations utilisent leur propre syntaxe.
Une annotation s'utilise avec le caractère @ suivi du nom de l'annotation : elle doit obligatoirement précéder l'entité
qu'elle annote.
Par convention, les annotations s'utilisent sur une ligne dédiée.
Les annotations peuvent s'utiliser sur les packages, les classes, les interfaces, les méthodes, les constructeurs et les
paramètres de méthodes.
[email protected]
COURS EP&TP
Annotations
111 Une annotation peut avoir un ou plusieurs attributs : ceux-ci sont précisés entre parenthèses,
séparés par une virgule. Un attribut est de la forme clé=valeur.
Le tableau peut contenir des annotations.
Un attribut peut être de type tableau : dans ce cas, les

différentes valeurs sont fournies entre accolades, chaque
valeur placée entre guillemets et séparée de la suivante
par une virgule
[email protected]
COURS EP&TP
L'annotation @Override
112
Cette annotation est un marqueur utilisé par le compilateur pour vérifier la réécriture de méthodes héritées.
@Override s'utilise pour annoter une méthode qui est une réécriture d'une méthode héritée. Le compilateur lève une
erreur si aucune méthode héritée ne correspond.
Son utilisation n'est pas obligatoire mais recommandée car elle permet de
détecter certains problèmes.
[email protected]
COURS EP&TP
L'annotation @Deprecated
113 Cette annotation a un rôle similaire au tag de même nom de Javadoc.
C'est un marqueur qui précise que l'entité concernée est obsolète et qu'il ne faudrait plus l'utiliser.
Elle peut être utilisée avec une classe, une interface ou un membre (méthode ou champ)
Les entités marquées avec l'annotation

@Deprecated devraient être documentées
avec le tag @deprecated de Javadoc en lui
fournissant la raison de l'obsolescence et
éventuellement l'entité de substitution.
Il est important de tenir compte de la casse :
@Deprecated pour l'annotation et
@deprecated pour Javadoc.
Lors de la compilation, le compilateur donne
une information si une entité obsolète est
utilisée.
[email protected]
COURS EP&TP
EP11
[email protected]
114 1. Créer une classe Médicament avec 2 attributs nom(String) et qteStock(int).(V1)
A
2. Créer une classe Carburant avec 2 attributs type(String)et stock(int). (V2)
3. Ajouter les accesseurs ,les modificateurs ,un constructeur qui initialise tous les attribus ainsi que la
méthode toString() .pour les deux classes.
(Extraits EFF 2023 :4pts)
B 1.
Créez une classe Voiture avec des attributs pour la marque, le modèle et l'année.
2. Ajoutez un constructeur à la classe Voiture pour initialiser ses attributs.
3. Ajoutez des accesseurs pour les attributs de la classe Voiture.
4. Faites en sorte que la classe Voiture ne puisse pas être héritée.
5. Ajoutez un compteur à la classe Voiture qui compte le nombre total de voitures créées.
6. Surchargez la méthode equals pour la classe Voiture afin de comparer deux voitures par marque, modèle et
année.
7. Ajoutez une méthode afficherInfo à la classe Voiture qui affiche les détails de la voiture.
8. Surchargez la méthode afficherInfo pour qu'elle puisse également afficher le prix de la voiture.
9. Créez une classe VoitureElectrique qui hérite de Voiture et qui a un attribut supplémentaire pour l'autonomie de
la batterie.
10. Utilisez le polymorphisme pour créer un tableau de Voiture qui peut contenir à la fois des voitures et des voitures
électriques. Affichez les informations de toutes les voitures dans le tableau.
11. Redéfinissez la méthode afficherInfo dans VoitureElectrique pour inclure également l'autonomie de la batterie.
12. Créez une interface Vehicule avec une méthode demarrer. Faites en sorte que Voiture implémente cette interface.
COURS EP&TP
[email protected]
EP12
115
1. Créez une classe Livre qui a des attributs pour le titre, l'auteur et l'année de publication.
2. Créez une classe abstraite Personne avec des attributs nom et adresse.
3. Ajoutez des classes Emprunteur et Employe qui étendent Personne.
4. Ajoutez un compteur dans la classe Livre pour garder une trace du nombre total de livres créés.
5. Créez une classe Magazine qui étend Livre et qui a un attribut supplémentaire pour le genre du magazine.
6. Redéfinissez la méthode toString dans Livre et Magazine pour qu'elle affiche les détails pertinents pour
chaque type.
7. Créez une interface Empruntable avec une méthode emprunter. Faites en sorte que Livre et Magazine
implémentent cette interface.
8. Implémentez la méthode equals dans la classe Livre pour comparer deux livres en fonction de leur titre,
auteur et année de publication.
9. Créez une méthode statique dans Livre qui compare deux livres en fonction de leur année de publication.
10. Créez une méthode qui accepte un objet de type Empruntable et affiche les détails de l'objet emprunté.
11. ajouter un attribut de prix à un livre et calculer le prix total d'un ensemble de livres.
COURS EP&TP
[email protected]
TP02
116
Vous travaillez pour une entreprise de location de voitures.

Votre tâche est de développer un système pour gérer la flotte de voitures de l'entreprise.
1. Créez une classe Voiture qui a des attributs pour l'immatriculation, la marque, le modele, et l'etat (disponible,
louée, en maintenance).
2. Créez une classe abstraite Personne avec des attributs nom et prenom.
3. Ajoutez des classes Client et Employe qui étendent Personne.
4. Dans la classe Voiture, gardez une trace du nombre total de voitures dans la flotte.
5. Créez une classe Camion qui étend Voiture et qui a un attribut supplémentaire pour la capaciteDeCharge.
6. Redéfinissez la méthode toString dans Voiture et Camion pour afficher les détails pertinents pour chaque type
de véhicule.
7. Créez une interface GestionCRUD avec des méthodes ajouter, lire, mettreAjour, et supprimer.
8. Créez une classe GestionFlotte qui implémente cette interface pour gérer un tableau de Voiture.
9. Implémentez la méthode equals dans la classe Voiture pour comparer deux voitures en fonction de leur
immatriculation.
10.Utiliser les interfaces graphiques et la base de donnée pour gérer cette application
COURS EP&TP
[email protected]
117
PARTIE 6 :Correspondance UML-JAVA

Implémentation UML en Java
COURS EP&TP
Implémentation du diagramme de classe
118
Une classe est représentée par un rectangle séparé en trois
parties :
•la première partie contient le nom de la classe
•la seconde contient les attributs de la classe
•la dernière contient les méthodes de la classe
Pour définir un attribut, il faut préciser son nom suivi du

public class MaClasse { }
caractère ":" et du type de l'attribut.
Le modificateur d'accès de l'attribut doit précéder son nom
et peut prendre les valeurs suivantes :
Caractère Rôle
+ accès public
# accès protected
- accès private
public class MaClasse {
public int champPublic = 0;
protected double champProtected = 0;
private boolean champPrive = false;
[email protected] }
COURS EP&TP
Implémentation du diagramme de classe
119
[email protected]
Les modificateurs des méthodes sont identiques à

ceux des attributs.
Les paramètres de la méthode peuvent être précisés
en les indiquant entre les parenthèses sous la forme
nom : type.
Si la méthode renvoie une valeur son type doit être
précisé après un signe ":".
public class MaClasse {
Il n'est pas obligatoire d'inclure dans le diagramme tous les public void methode1(int valeur){ }
attributs et toutes les méthodes d'une classe : seules les protected String methode2(){ }
entités les plus significatives et utiles peuvent être private void methode3(){ } }
mentionnées.
'implémentation d'une interface public class MaClasse implements MonInterface

{ public int champPublic = 0;
protected double champProtected = 0;
private boolean champPrive = false;
public operation() {
COURS EP&TP
Résumé des implémentations UML en Java

[email protected]
120
COURS EP&TP

[email protected]
121
COURS EP&TP

[email protected]
122
COURS EP&TP

[email protected]
123
COURS EP&TP

[email protected]
124
COURS EP&TP

[email protected]
125
COURS EP&TP
126
[email protected]
En UML, la navigabilité est représentée par une flèche. La direction de la flèche indique la navigabilité. Si
aucune flèche n'est présente, l'association est considérée comme bidirectionnelle, c'est-à-dire que les deux
classes peuvent naviguer l'une vers l'autre.
Si la flèche pointe d'une classe A vers une classe B, cela signifie que la classe A connaît la classe B, mais
pas l'inverse. En termes de programmation, cela pourrait signifier que la classe A a une référence ou un
pointeur vers un objet de la classe B.
COURS EP&TP
Exemple :Associations Client -Commande
127
Prenons l'exemple d'une classe Commande et d'une classe Client.
•Si une flèche pointe de Commande à Client, cela signifie qu'une commande "connaît" son client, mais
qu'un client n'a pas nécessairement connaissance de ses commandes directement.
•Si aucune flèche n'est présente, cela signifie qu'une commande connaît son client et qu'un client connaît
également ses commandes.
•Si une croix est présente du côté de Client, cela signifie que le client n'a aucune connaissance des
commandes, même si les commandes connaissent leur client.
[email protected]
COURS EP&TP
Exemple Client-Commande: Association unidirectionnelle
128
Flèche de Commande à Client (Navigabilité unidirectionnelle):

La classe Commande a un attribut de type Client,mais la classe
Client n'a pas d'attribut lié à Commande:
public class Client {

private String nam
}
public class Commande {
private Client client;
public Commande(Client client) {

this.client = client;
}
}
[email protected]
Exemple Client-Commande:Association bididirectionnelle
[email protected]
Aucune flèche (Navigabilité bidirectionnelle):
129 La classe Commande a un attribut de type Client,
et la classe Client a également un attribut de type List<Commande>
pour stocker toutes ses commandes:
import java.util.ArrayList;
import java.util.List;
public class Client {
private String name;
private List<Commande> commandes = new ArrayList<>();
public void addCommande(Commande commande) {
commandes.add(commande);
}
}
public class Commande {
private Client client;
public Commande(Client client) {
this.client = client;
client.addCommande(this);
}
}
COURS EP&TP
[email protected]
130
COURS EP&TP
COURS EP&TP
[email protected]
131
[email protected]
132
COURS EP&TP
COURS EP&TP
133
Modélisez les relations suivantes avec diagramme de classe :

1. Une école a plusieurs enseignants, et chaque enseignant enseigne à plusieurs étudiants.
2. Un client peut avoir plusieurs comptes bancaires identifiés par un numéro de compte unique.
3. Une université a plusieurs départements, et chaque département offre plusieurs cours. Cependant, la
suppression d'un département ne supprime pas nécessairement les cours.
4. Une entreprise a plusieurs départements, et chaque département a plusieurs employés.
5. Un zoo a plusieurs animaux, dont certains sont des oiseaux et d'autres des mammifères. Les oiseaux
peuvent voler, tandis que les mammifères peuvent courir. Modélisez cette relation.
6. Si un département est supprimé, tous ses employés sont également supprimés.
7. Un directeur supervise plusieurs employés, mais un employé ne peut avoir qu'un seul directeur. Modélisez
cette relation.
8. Vous gérez un système de billetterie pour un théâtre. Chaque billet est associé à un siège particulier dans
la salle. Toutefois, un siège n'a pas besoin de connaître le billet qui lui est associé.
9. Vous gérez un réseau social. Chaque utilisateur peut être ami avec d'autres utilisateurs. Les utilisateurs
peuvent voir la liste de leurs amis et vice versa.
COURS EP&TP
EP14
[email protected]
134
1. Implémentez le diagramme de classe suivant
en java .
A
Dans le main :
2. Créer 5 spécialités et 4 professeurs.
3. Afficher la liste des professeurs par
spécialité.
NB : l’identifiant est auto incrément.
1. Implémentez le diagramme de classe suivant en java :

• Personne est une classe abstraite B
• Le développeur aura une augmentation de 20% par rapport à son salaire
normal
• Le manager aura une augmentation de 35% par rapport à son salaire normal .
2.Donner des tests
COURS EP&TP
EP15
[email protected]
135
Une bibliothèque souhaite informatiser sa gestion.
A
Elle possède plusieurs livres et plusieurs adhérents. Chaque livre a un titre, un auteur et un
numéro ISBN. Les adhérents ont un nom, un prénom et un numéro d'adhérent. Un adhérent
peut emprunter plusieurs livres, mais un livre ne peut être emprunté que par un seul adhérent
à la fois.
1.Modélisez le système en UML, en incluant les classes, attributs, méthodes ..
2.Implémentez le modèle en Java.
Un magasin souhaite informatiser sa gestion des produits.

Il dispose de plusieurs types de produits : des livres et des vêtements. Chaque produit a un prix
B et une quantité en stock. Les livres ont un titre, un auteur et un numéro ISBN. Les vêtements
ont une taille et un type (par exemple, chemise, pantalon). Le magasin a aussi une section
"Promotion" qui peut contenir plusieurs produits avec une réduction applicable.
1.Modélisez le système en UML, en incluant les classes, attributs, méthodes, héritage,
interfaces, associations, agrégation et composition.
2.Implémentez le modèle en Java.
COURS EP&TP
TP03
[email protected]
136
Une université veut gérer ses étudiants, ses professeurs, ses cours et ses départements et sa médiathèque:
➢ Chaque étudiant est inscrit à plusieurs cours.
➢ Chaque cours est enseigné par un seul professeur mais un professeur peut enseigner plusieurs cours.
➢ Chaque département offre plusieurs cours, mais chaque cours n'appartient qu'à un seul département.
➢ Lorsqu'un département est supprimé, tous ses cours sont également supprimés.
➢ Chaque professeur appartient à un seul département.
➢ Les étudiants et les professeurs peuvent emprunter des ouvrages de la médiathèque. Certains ouvrages
sont des livres, d'autres sont des magazines.
➢ Les livres peuvent être réservés, mais pas les magazines.
➢ De plus, certains départements ont des laboratoires de recherche associés, mais un laboratoire peut
exister sans être associé à un département.
1. Modéliser le diagramme de classe de ce projet .

2. Implémentez le projet en java.
3. Créer l’application en utilisant les interfaces graphiques et base de donnée MYSQL
COURS EP&TP
Enumérations
137
[email protected]
Les énumérations permettent de définir un ensemble fini de constantes, chacune d'entre-elles est
séparée des autres par une virgule. Comme ces champs sont constants, leur nom est en majuscule par
convention.
La définition d'une énumération ressemble à celle

d'une classe avec quelques différences :
•utilisation du mot clé enum introduit spécifiquement
dans ce but à la place du mot clé class
•un ensemble de valeurs constantes définies au début
du corps de la définition, chaque valeur étant séparée
par une virgule
•par convention le nom des constantes est en
majuscule
Une énumération peut prendre plusieurs formes et être
enrichie de fonctionnalités puisqu'une énumération est
une classe Java.
COURS EP&TP
Enumérations
138
Le nom utilisé dans la déclaration de l'énumération peut être utilisé comme
n'importe quelle classe dans la déclaration d'un type.
Une fois définie, il est possible d'utiliser l'énumération simplement en définissant
une variable du type de l'énumération.
[email protected]
COURS EP&TP
[email protected]
EP16
139
Créez une énumération Jour qui représente les jours de la semaine.
Ensuite, écrivez une méthode qui accepte un Jour en tant qu'argument et affiche si c'est un jour
ouvrable ou un week-end.
Créez une énumération Direction avec les valeurs NORD, SUD, EST, OUEST. Ajoutez une méthode opposee()
à l'énumération qui retourne la direction opposée.
Créez une énumération Niveau pour représenter les niveaux de gravité d'un log : INFO, DEBUG, WARNING, ERROR.
Chaque niveau doit avoir une description associée.
Créez une énumération Opération représentant les opérations arithmétiques de base: addition,
soustraction, multiplication et division.
Chaque opération doit être capable de calculer un résultat donné deux opérandes.
COURS EP&TP
TAF02
140 [email protected]
Application système de gestion des ressources humaines (SGRH).

Ce système gère toutes les informations concernant les employés, leur recrutement, leurs salaires, leurs promotions, leurs
congés, etc. Il est crucial pour de grandes organisations pour gérer efficacement leur personnel.
Chaque entité principale du SGRH peut être modélisée comme une classe:
Employe ,Departement ,Poste ,Conge
Manager, Technicien, Directeur peuvent tous être des sous-classes de Employe.
Une méthode calculerSalaire() dans Employe pourrait avoir des implémentations différentes pour Manager (qui pourrait
inclure des bonus) et Technicien.
La classe Employe peut avoir une méthode demanderConge(). L'implémentation exacte de cette méthode (comment le
congé est enregistré dans la base de données, comment il est approuvé, etc.) est cachée aux autres classes ou modules qui
utilisent cette méthode.
Un Departement contient plusieurs Employes (Composition).
Un Employe peut avoir un Poste (Association).
Un Manager pourrait être responsable de plusieurs Techniciens (Aggrégation).
Interfaces et classes abstraites: Pour définir des contrats ou des comportements communs.
1.Réaliser le diagramme de classe de ce Système .
2.Implementer le projet avec Orienté objet de Java .
3.Réaliser L’interface graphique de cette Application avec l’implémentation de la base de donnée MYSQL
COURS EP&TP
[email protected]
141
PARTIE 7 :
Les collections & les expressions lambda
COURS
Les collections EP&TP
142 Les collections en Java sont utilisées pour stocker, manipuler et organiser des groupes d'objets.
Les collections en Java offrent un large éventail d'opérations pour ajouter, supprimer, rechercher, trier,
filtrer et parcourir les éléments.
Voici les
1.List (Liste) : Une liste ordonnée qui permet les doublons. Les éléments sont accessibles par leur indice.
principales •ArrayList: Implémentation dynamique basée sur un tableau pour les listes.
interfaces et •LinkedList: Implémentation basée sur une liste chaînée double pour les listes.
classes du Java 2.Set (Ensemble) : Une collection qui ne permet pas de doublons. Utilisé pour stocker des éléments
Collections uniques.
Framework : •HashSet: Implémentation basée sur une table de hachage pour les ensembles.
•TreeSet: Implémentation basée sur un arbre binaire pour les ensembles triés.
3.Map (Carte) : Une association clé-valeur où chaque clé est unique.

•HashMap: Implémentation basée sur une table de hachage pour les paires clé-valeur.
•TreeMap: Implémentation basée sur un arbre binaire pour les paires clé-valeur triées.
•LinkedHashMap: Implémentation basée sur une liste chaînée pour les paires clé-valeur, maintient l'ordre d'insertion.
4.Queue (File d'attente) : Une collection qui suit l'ordre de file d'attente (FIFO - First-In-First-Out).
•LinkedList: Peut être utilisée pour implémenter une file d'attente.
•PriorityQueue: Implémentation basée sur un tas pour les files d'attente à priorité.
5.Deque (Double-ended queue) : Une queue où les éléments peuvent être ajoutés ou supprimés des deux extrémités.
•LinkedList: Peut être utilisée pour implémenter une double-ended queue.
[email protected]
COURS EP&TP
Les listes
143
En Java, les listes sont des collections ordonnées qui permettent les doublons. Elles sont implémentées par
l'interface List
Les listes fournissent des opérations pour ajouter, supprimer, rechercher et accéder aux éléments par leur
indice.
Voici les principales implémentations de l'interface List en Java
•ArrayList :Implémentation dynamique basée sur un tableau. (traité précédemment ArrayList )

•Permet un accès rapide aux éléments par leur indice (O(1)).
•Convient pour les opérations fréquentes de lecture et d'accès, mais moins efficace pour l'insertion et la suppression
d'éléments au milieu de la liste.
•Non synchronisé (non thread-safe).
•LinkedList :Implémentation basée sur une liste chaînée double.

•Permet des opérations d'insertion et de suppression rapides (O(1))
pour les éléments au début ou à la fin de la liste.
•Moins efficace pour accéder aux éléments par leur indice (O(n)) car
un parcours depuis le début ou la fin de la liste est nécessaire.
•Non synchronisé (non thread-safe).
[email protected]
COURS EP&TP
Les listes
144
[email protected]
À partir de Java 9, la classe List a introduit des méthodes statiques pour créer des listes immuables facilement.
Ces méthodes sont des raccourcis pratiques pour créer des listes avec un nombre donné d'éléments sans avoir à
utiliser les constructeurs complets des implémentations ArrayList ou List.
Voici les principales méthodes similaires à List.of pour créer des listes immuables :
•List.of :Crée une liste immuable avec les éléments spécifiés.

•La liste est immuable, ce qui signifie que les opérations d'ajout, de suppression ou de modification ne sont pas
autorisées.
COURS EP&TP
Les Listes
145
[email protected]
•List.copyOf :Crée une liste immuable en copiant les éléments d'une autre liste.
•La liste résultante est immuable, même si la liste source est modifiable.
COURS EP&TP
EP17
146
[email protected]
Vous êtes responsable de la gestion des stagiaires d'un centre de formation.

Chaque stagiaire a un nom, un numéro d'identification unique (ID) et une liste de notes pour
différents modules.
1.Créez une classe Stagiaire avec les attributs appropriés (nom, ID, liste de notes).
2.Dans la classe Stagiaire, implémentez une méthode pour calculer la moyenne des notes du
stagiaire.
3.Créez une classe CentreDeFormation qui contient une ArrayList de stagiaires.
4.Dans la classe CentreDeFormation, implémentez des méthodes pour:
•Ajouter un stagiaire.
•Supprimer un stagiaire par ID.
•Trouver un stagiaire par ID.
•Afficher la moyenne des notes de tous les stagiaires.
5.Dans une classe Main, créez une instance de CentreDeFormation et effectuez quelques opérations
pour tester vos implémentations.
Créer des stagiaires ,Ajouter des stagiaires au centre de formation ,afficher la moyenne ,trouver un
stagiaire par Id et supprimer le par id
COURS EP&TP
[email protected]
Les expressions lambda
147
Une expression lambda est utilisée pour représenter une interface fonctionnelle sous la forme d'une expression
de la forme :
(arguments) -> corps
L'opérateur -> sépare le ou les paramètres du bloc de code qui va les utiliser. Le type du paramètre n'est pas
obligatoire : le compilateur va tenter de réaliser une inférence du type pour le déterminer selon le contexte. Une
expression lambda est typée de manière statique. Ce type doit être une interface fonctionnelle.
() -> System.out.println("Hello World");
(x) -> x * x ;
(x, y) -> x + y ;
COURS EP&TP
Exemples d'expressions lambda
148
[email protected]
149
[email protected]
COURS EP&TP
150
[email protected]
[email protected]
Les références de méthodes
151
Les références de méthodes permettent d'offrir une syntaxe simplifiée pour invoquer une méthode comme une
expression lambda : elles offrent un raccourci syntaxique pour créer une expression lambda dont le but est
d'invoquer une méthode ou un constructeur.
Type Syntaxe Exemple

Référence à une méthode
nomClasse::nomMethodeStatique String::valueOf
statique
Référence à une méthode sur
objet::nomMethode personne::toString
une instance
Référence à une méthode d'un
nomClasse::nomMethode Object::toString
objet arbitraire d'un type donné
Référence à un constructeur nomClasse::new Personne::new
COURS EP&TP
COURS
quelques exemples de références EP&TP
152
Le tableau ci-dessous donne quelques exemples de références de méthodes et leurs expressions
lambda équivalentes :
Type Référence de méthode Expression lambda

System.out::println x -> System.out.println(x)
Référence à une méthode statique
Math::pow (x, y) -> Math.pow(x, y)
Référence à une méthode sur une
monObject::maMethode x -> monObject.maMethode(x)
instance
Référence à une méthode d'un

String::compareToIgnoreCase (x, y) -> x.compareToIgnoreCase(y)
objet arbitraire d'un type donné
Référence à un constructeur MaClasse::new () -> new MaClasse();
[email protected]
COURS EP&TP
Streams
153
[email protected] Un stream est une séquence d'éléments qui peuvent être traités en parallèle ou séquentiellement.
Les streams peuvent être créés à partir de différentes sources, notamment les collections.
Créer un stream à partir d'une liste et filtrer les éléments :

List<String> myList = Arrays.asList("a1", "a2", "b1", "c2", "c1");
myList
.stream()
.filter(s -> s.startsWith("c"))
.map(String::toUpperCase)
.sorted()
.forEach(System.out::println); // Affiche C1 et C2
Calculer la somme des nombres dans une liste :

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
.mapToInt(Integer::intValue)
.sum();
COURS EP&TP
expressions lambda et streams
154
[email protected] Les expressions lambda sont souvent utilisées en combinaison
avec les streams pour réaliser des opérations de traitement sur
des séquences de données.
Quelques méthodes courantes de l'API Stream :

•filter(): filtre les éléments en fonction d'un prédicat.
•map(): transforme les éléments.
•sorted(): trie les éléments.
•collect(): convertit le stream en une autre forme (par exemple une List ou un Set).
•forEach(): exécute une action pour chaque élément.
•reduce(): réduit le stream à une valeur unique.
Exemple :Trouver les chaînes de caractères qui commencent

par "a" dans une liste et les afficher en majuscules :
List<String> items = Arrays.asList("apple", "banana", "grapes", "pear");
items.stream()
.filter(s -> s.startsWith("a"))
.map(String::toUpperCase)
.forEach(System.out::println); // Affiche APPLE
COURS EP&TP
quelques exemples de références
155
[email protected]
COURS EP&TP
[email protected]
156
Les listes
:expressions
lambdas
COURS EP&TP
Listes de tri
157
[email protected]
Vous pouvez trier les listes en utilisant leur

ordre naturel de via lambdas pour définir
le Comparator.compare() En règle générale,
dans Java 8, vous utilisez une expression
lambda ou une référence de méthode pour la
définition de la méthode compare.
COURS
Supprimer des membres de la liste EP&TP
158
[email protected] en fonction de la condition
La méthode removeIf permet de supprimer des éléments de liste en fonction d’une condition.
COURS EP&TP
Méthodes de collecte utiles
159 La classe java.util.Collections fournit des fonctionnalités utiles pour travailler avec des collections.
Méthode Description
Collections.copy(liste, liste) Copier une collection dans une autre
Collections.reverse(liste) Inverser l’ordre de la liste
Collections.shuffle(liste) Mélanger la liste
Collections.sort(liste) Trier la liste
[email protected]
COURS EP&TP
[email protected] Utilisation de Collections.sort et
160 Comparator en Java
Trier une collection en Java est facile, il suffit d’utiliser le Collections.sort(Collection) pour trier vos
valeurs. Le code suivant montre un exemple pour cela.
COURS EP&TP
[email protected] Utilisation de Collections.sort et
161 Comparator en Java
Cela est possible car Integer implémente
l’interface Comparable. Cette interface définit la
méthode de comparaison qui effectue la
comparaison par paires des éléments et renvoie -1
si l’élément est plus petit que l’élément comparé,
0 s’il est égal et 1 s’il est plus grand.
Si vous souhaitez trier différemment, vous pouvez
définir votre implémentation personnalisée en
fonction de l’interface Comparator via une
expression lambda
Vous pouvez trier par n’importe quel attribut

ou même une combinaison d’attributs. Par
exemple, si vous avez des objets de
type Person avec les attributs
appelés income et dataOfBirth vous pouvez
définir différentes implémentations
de Comparator et trier les objets en fonction
de vos besoins.
COURS EP&TP
L'interface Iterator
162
[email protected]
L'interface Iterator en Java est utilisée pour parcourir une collection d'objets, un par un.
Elle dispose de deux méthodes principales : hasNext() et next().
La méthode next() de l'interface Iterator est utilisée pour obtenir l'élément suivant dans la collection.
Avant d'appeler next(), il est généralement bon de vérifier s'il y a un élément suivant en utilisant hasNext(),
car si next() est appelé alors qu'il n'y a pas d'élément suivant, une exception NoSuchElementException sera levée.
List<String> list = Arrays.asList("Apple", "Banana",

"Cherry");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
String fruit = iterator.next();
System.out.println(fruit);
L'interface Iterator fournit également une

méthode remove(), qui permet de
supprimer le dernier élément renvoyé par
next() de la collection sous-jacente
COURS EP&TP
[email protected]
L'interface Iterator
163
Exemple avec Map
//Itérer sur les clés

Iterator<String> keyIterator = map.keySet().iterator();
while (keyIterator.hasNext()) {
String key = keyIterator.next();
System.out.println(key);
}
//Itérer sur les valeurs
Iterator<Integer> valueIterator = map.values().iterator();
while (valueIterator.hasNext()) {
Integer value = valueIterator.next();
System.out.println(value);
}
// Itérer sur les entrées (paires clé-valeur) :
Iterator<Map.Entry<String, Integer>> entryIterator = map.entrySet().iterator();
while (entryIterator.hasNext()) {
Map.Entry<String, Integer> entry = entryIterator.next();
System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
}
COURS
[email protected] EP18 EP&TP
164
A 1.Créez une liste de noms.
2.Utilisez la méthode forEach avec une expression lambda pour imprimer chaque nom en majuscules
B
1.Créez une liste d'entiers.
2.Utilisez un itérateur pour parcourir et afficher chaque élément de la liste.
3.Utilisez le même itérateur pour supprimer tous les nombres impairs de la liste.
C 1. Définissez une interface fonctionnelle Callback avec une méthode execute.

2. Écrivez une méthode runTask qui prend un objet Callback en tant que paramètre. La méthode runTask devrait
imprimer "Début de la tâche", exécuter le callback, puis imprimer "Fin de la tâche".
3. Utilisez une expression lambda pour passer un callback à la méthode runTask qui imprime "Callback en cours
d'exécution".
4. Modifiez l'interface Callback pour accepter un paramètre de type String et l'imprimer lors de son exécution.
5. Mettez à jour la méthode runTask et votre expression lambda pour s'adapter à ce changement.
6. Écrivez une méthode processData qui prend une List<String> et un Callback comme paramètres. La méthode
processData devrait parcourir chaque élément de la liste, le transformer en majuscules, et ensuite utiliser le callback
pour imprimer chaque élément transformé.
7. Utilisez une expression lambda pour passer un callback approprié à la méthode processData.
COURS EP&TP
165 ➢ Filtrer une liste de nombres pour ne conserver que les nombres pairs, puis les
A
multiplier par 2 et afficher le résultat.
➢ Convertir une liste de chaînes en une liste de leurs longueurs
➢ Trouver le mot le plus long dans une liste de mots.
➢ Calculer la somme des carrés des nombres uniques dans une liste
➢ Convertir une liste de chaînes en une chaîne unique, séparée par des virgules.
Vous avez une liste de produits, chacun avec un nom, un prix et une catégorie.
B
1. Créer la classe Produit.
2. Dans le main créer une liste immuable de produits .
3. Trouver tous les produits de la catégorie "Électronique" coûtant plus de 500
unités et afficher leurs noms.
C
Vous avez une liste d'employés, chacun avec un nom, un département et un salaire.
1. Créer la classe Employe
2. Dans le main créer une liste immuable des employées .
3. Trouver l'employé le mieux payé dans le département "Informatique".
COURS EP&TP
Les Sets
166
[email protected]
Les ensembles (sets) en Java sont utilisés pour stocker des éléments uniques, c'est-à-dire qu'ils ne permettent pas
de doublons.
Deux des implémentations courantes de l'interface Set sont HashSet et TreeSet.
HashSet :
•HashSet est une
implémentation de Set basée
sur une table de hachage.
•Il offre une recherche rapide
(O(1)) pour les opérations
d'ajout, de suppression et de
recherche d'éléments.
•Il n'ordonne pas les éléments
selon un ordre spécifique.
•Ne garantit pas l'ordre
d'itération des éléments.
•Ne permet pas de stocker des
éléments en doublon.
COURS EP&TP
Les Sets :TreeSet
167
[email protected]
TreeSet est une implémentation de Set basée sur un arbre binaire équilibré (red-black tree).
•Il trie automatiquement les éléments dans l'ordre naturel (par exemple, numérique ou alphabétique).
•Offre un temps de recherche, d'ajout et de suppression de l'ordre O(log n), où n est le nombre d'éléments dans l'ensemble.
•Les éléments doivent être comparables, soit en utilisant l'ordre naturel (en implémentant l'interface Comparable) soit en
utilisant un Comparator.
COURS Sets :exemples EP&TP
[email protected]
168
COURS EP&TP
[email protected] Sets:Exemple
169
COURS EP&TP
[email protected] Map & hashMap
170 En Java, Map et HashMap sont deux concepts liés aux collections qui permettent de stocker des paires
clé-valeur.
Map (Carte) :
Une Map est une interface qui représente une structure de données permettant de stocker des
associations clé-valeur. Chaque clé dans une Map est unique, ce qui signifie qu'il ne peut y avoir qu'une
seule occurrence d'une clé donnée.
Les méthodes principales de l'interface

Map sont :
put(K key, V value): Ajoute une paire
clé-valeur à la Map.
get(Object key): Récupère la valeur
associée à la clé spécifiée.
remove(Object key): Supprime la paire
clé-valeur associée à la clé spécifiée.
containsKey(Object key): Vérifie si la
clé spécifiée est présente dans la Map.
keySet(): Renvoie un ensemble
contenant toutes les clés de la Map.
COURS EP&TP
Map & hashMap
171
HashMap est l'une des implémentations de l'interface Map.
C'est une classe qui utilise une table de hachage pour stocker les paires
clé-valeur, ce qui permet d'obtenir des temps de recherche et d'insertion
rapides. Les clés dans une HashMap doivent être uniques et les valeurs
peuvent être en doublon.
[email protected]
COURS EP&TP
Map & hashMap
172 L’interface Map définit un objet qui mappe les clés aux valeurs. Une carte ne peut pas contenir de
[email protected]
clés en double ;
Chaque clé peut correspondre à au plus une valeur. La classe HashMap est une implémentation
efficace de l’interface Map
COURS EP&TP
Map & hashMap
173
[email protected]
COURS EP&TP
Map & hashMap
174
[email protected]
COURS EP&TP
[email protected]
L'interface Iterator avec Map
175
//Itérer sur les clés

Iterator<String> keyIterator = map.keySet().iterator();
while (keyIterator.hasNext()) {
String key = keyIterator.next();
System.out.println(key);
}
//Itérer sur les valeurs
Iterator<Integer> valueIterator = map.values().iterator();
while (valueIterator.hasNext()) {
Integer value = valueIterator.next();
System.out.println(value);
}
// Itérer sur les entrées (paires clé-valeur) :
Iterator<Map.Entry<String, Integer>> entryIterator = map.entrySet().iterator();
while (entryIterator.hasNext()) {
Map.Entry<String, Integer> entry = entryIterator.next();
System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
}
COURS EP&TP
Map & hashMap
176
[email protected]
Vous pouvez utiliser la méthode getOrDefault() pour renvoyer la valeur d’une clé ou une
valeur par défaut si la clé n’est pas présente dans le mappage.
Le computeIfAbsent calcule et ajoute une entrée à la carte si elle n’est pas présente dans la carte
COURS EP&TP
EP20
[email protected]
177 A Pourquoi utiliser une HashMap plutôt qu'une ArrayList pour stocker des paires clé-valeur ?
B
Calculer la fréquence des mots(nombres répétés) dans String[] phrases = {
une liste de phrases "Bonjour tout le monde",
"Comment ça va aujourd'hui",
"Le monde est petit"
};
Créér une hashMap de programmation suivante
-Vérifier si une clé de java existe dans la Map (Java", "James Gosling");
C
("Python", "Guido van Rossum");
-Afficher la valeur de python
("JavaScript", "Brendan Eich");
-Supprimer C++ ("C++", "Bjarne Stroustrup");
-vider la liste ("Swift", "Chris Lattner");
-afficher la liste finale
-Transformer la Map en deux tableaux :tableau de
D
• Ajouter des lettres à une ArrayList
langages et tableaux de createurs
• Utliser hashMap pour Trouver les doublons la liste.
• Fusionner deux HashMap <Stringer ,Integer>
E
Créez une HashMap qui stocke des chaînes de caractères comme clés et des entiers comme valeurs.
Ajoutez quelques paires clé-valeur à votre HashMap.
Utilisez une expression lambda pour parcourir la HashMap et imprimer chaque clé et valeur.
COURS EP&TP
EP21
[email protected]
178
1.Créez une HashSet de noms.
2.Utilisez l'interface Iterator pour parcourir l'ensemble.
A
3.Pendant l'itération, utilisez une expression lambda pour afficher uniquement les noms qui ont plus de
5 lettres.
4.Créez un Set d'entiers.
5.Utilisez une expression lambda pour filtrer et imprimer tous les nombres pairs du Set.
Supposons que vous soyez en charge de la gestion d'une bibliothèque.

1. Créez une classe Book avec les attributs suivants :title (String),author (String),isbn (String)
2. Dans votre classe principale (par exemple LibraryManager), créez une HashMap pour stocker les livres de la
B bibliothèque.
La clé de la HashMap sera le isbn du livre et la valeur sera l'objet Book lui-même.
3. Créez une méthode pour ajouter un livre à la bibliothèque.
4. Créez une méthode pour supprimer un livre de la bibliothèque en utilisant son isbn.
5. Les auteurs peuvent écrire plusieurs livres. Créez un HashSet pour stocker tous les livres d'un auteur particulier.
6. Créez une méthode pour imprimer tous les livres d'un auteur particulier.
7. Assurez-vous qu'un auteur ou un isbn ne peut pas être dupliqué.
COURS EP&TP
[email protected]
Les génériques (generics)
179 En Java, les génériques (ou "generics" en anglais) permettent aux types (classes et
interfaces) d'être paramétrés par d'autres types. Cela offre une plus grande flexibilité
et type-sécurité lors de la création de structures de données et d'APIs.
public class Boite<T> {
private T objet;
Vous pouvez définir une
classe générique avec un ou public void setObjet(T objet) {
plusieurs types paramétrés: this.objet = objet;
}
public T getObjet() {
return objet;
}
}
L'utilisation de cette classe:

Boite<String> boiteAvecChaine = new Boite<>();
boiteAvecChaine.setObjet("Hello, Generics!");
String chaine = boiteAvecChaine.getObjet();
COURS EP&TP
[email protected]
180 Classes génériques avec plusieurs paramètres
COURS EP&TP
[email protected]
181
Les interfaces peuvent également être génériques:
public interface Comparateur<T> {

int compare(T o1, T o2);
}
Méthodes génériques
En plus des classes et interfaces génériques,
vous pouvez également avoir des méthodes génériques:
public static <T> void afficher(T[] elements) {

for (T element : elements) {
System.out.println(element);
}
}
COURS EP&TP
[email protected]
EP22
182
1: Créez une classe générique Box<T> qui a une propriété privée de type T. Fournissez des méthodes pour définir (set()) et
obtenir (get()) la valeur.
2: Écrivez une méthode générique statique printArray qui peut prendre un tableau d'objet de n'importe quel type et imprimer
tous les éléments.
3: Écrivez une méthode qui prend un List<?> et imprime chaque élément de la liste. Essayez d'ajouter un élément à cette liste
dans la méthode et observez ce qui se passe.
4: Créez une classe générique Pair<K, V> où K est la clé et V est la valeur. Cette classe doit avoir deux propriétés, une de type K
et une de type V. Fournissez des méthodes pour définir et obtenir les valeurs de K et V.
5: Définissez une interface générique Listable<T> avec deux méthodes: add(T item) pour ajouter un élément à la liste et T
get(int index) pour obtenir un élément à un index spécifique.
6: Créez une classe générique Library<T extends Book>. Cette classe devrait avoir une liste de livres. Ajoutez des méthodes
pour ajouter un livre, supprimer un livre et trouver un livre par son titre.
COURS EP&TP
TP04
183
Créer une application pour gérer les commandes passées par des clients dans un magasin.
1. Créez une classe Produit avec les attributs suivants: codeProduit, nom, et prix .
2. Créez une classe Commande avec les attributs suivants: idCommande, client et une ArrayList<Produit>
pour stocker les produits commandés.
3. Créez une classe générique Gestionnaire<T> qui aura une méthode pour ajouter un élément, une pour le
supprimer, et une pour le trouver par id (si T est une Commande).
4. Dans le Gestionnaire<Commande>, ajoutez une méthode qui permet de trouver toutes les commandes
d'un client donné en utilisant une expression lambda.
5. Créer un Test.
[email protected]
COURS EP&TP
[email protected]
184
PARTIE 8 :
Les fichiers & threads
COURS EP&TP
Fichiers: Lire et écrire
[email protected]
185 La gestion des entrées/sorties (I/O) en Java est essentielle pour lire et écrire des données,
que ce soit à partir de fichiers, de sockets réseau, ou d'autres sources.
• Les classes InputStream et OutputStream sont les superclasses de base pour la lecture et l'écriture de
données binaires (images ,adio..)
• Pour traiter des données textuelles, vous utiliseriez généralement les classes Reader et Writer.
• InputStream et OutputStream :Utilisée pour ecrire et lire des données sous forme de bytes à partir d'une
source (fichier, socket, etc.).
font toutes partie du package java.io
Utiliser FileReader et FileWriter pour les fichiers texte :
Lire depuis un fichier :

Écrire dans un fichier :
try (FileReader reader = new
try (FileWriter writer = new FileReader("monFichier.txt")) {
FileWriter("monFichier.txt")) { int character;
writer.write("Ceci est un exemple de while ((character = reader.read()) != -1) {
texte."); System.out.print((char) character);
} catch (IOException e) { }
e.printStackTrace(); } catch (IOException e) {
} e.printStackTrace();
}
COURS EP&TP
Fichiers :Ecrire et lire
186
Utiliser BufferedReader et BufferedWriter pour une
lecture/écriture plus efficace :

try (BufferedWriter writer = new try (BufferedReader reader = new
BufferedWriter(new BufferedReader(new
FileWriter("monFichier.txt"))) { FileReader("monFichier.txt"))) {
writer.write("Ceci est un exemple String line;
de texte."); while ((line = reader.readLine()) != null)
} catch (IOException e) { {
e.printStackTrace(); System.out.println(line);
} }
} catch (IOException e) {
e.printStackTrace();
}
[email protected]
COURS EP&TP
Fichiers :lire et ecrire
187
Utilisation de FileInputStream : Utilisation de FileOutputStream :
try (FileInputStream fis = new

FileInputStream("monFichier.txt")) { try (FileOutputStream fos = new
int content; FileOutputStream("monFichier.txt")) {
while ((content = fis.read()) != -1) { byte[] content = "Contenu à
// traiter le byte lu écrire".getBytes();
System.out.print((char) content); fos.write(content);
} } catch (IOException e) {
} catch (IOException e) { e.printStackTrace();
e.printStackTrace(); }
}
[email protected]
COURS EP&TP
Fichiers :lire et ecrire
188
[email protected]
Utiliser Files et Paths (Java 7 et versions ultérieures) :

List<String> lines = Arrays.asList("Première ligne", "Deuxième ligne");
Path path = Paths.get("monFichier.txt");
Files.write(path, lines, Charset.forName("UTF-8"));

Path path = Paths.get("monFichier.txt");
List<String> lines =
Files.readAllLines(path,Charset.forName("UTF8"));
for (String line : lines) {
System.out.println(line);
}
COURS EP&TP
Lire un fichier avec les exceptions
189
[email protected]
COURS EP&TP
EP23
190
[email protected]
A. Créez un fichier nommé source.txt et écrivez-y quelques lignes de texte.
2.Écrivez un programme Java qui fait ce qui suit :
•Ouvre le fichier source.txt en mode lecture.
A
•Crée (ou écrase s'il existe déjà) un fichier nommé destination.txt.
•Lit le contenu du fichier source.txt ligne par ligne et écrit chaque ligne dans le fichier destination.txt.
•Ferme les fichiers après la copie.
3.Exécutez le programme et vérifiez que destination.txt contient le même contenu que source.txt.
1.Choisissez une petite image (par exemple, image.jpg).

2.Écrivez un programme Java qui fait ce qui suit :
•Ouvre image.jpg en utilisant FileInputStream.
B
•Crée (ou écrase s'il existe déjà) un fichier nommé copie_image.jpg en utilisant FileOutputStream.
•Lit le contenu du fichier image.jpg byte par byte et écrit chaque byte dans le fichier copie_image.jpg.
•Ferme les fichiers après la copie.
3.Exécutez le programme et vérifiez que copie_image.jpg est une copie exacte de image.jpg
C. Ecrire un programme en Java permettant de lire les données à partir d'un

fichier plat "som.in", la première ligne de ce fichier indique le nombre de lignes
C
à lire, les lignes qui suivent contient deux nombres séparés par un espace. La
somme de ces nombres sera stockée dans un fichier plat "som.out".
COURS EP&TP
Multithreading
191
[email protected]
Le multithreading est une technique qui permet à une application de faire plusieurs choses
simultanément. Java possède une solide prise en charge du multithreading grâce à son API intégrée.
Voici une introduction au multithreading en Java :
La façon la plus basique de créer un thread en Java est d'utiliser la classe Thread.
class MonThread extends Thread {

public void run() {
System.out.println("Mon thread est en cours d'exécution.");
}
public static void main(String[] args) {
MonThread thread = new MonThread();
thread.start(); // démarre le thread
}
}
COURS EP&TP
[email protected]
Multithreading
192
Une autre façon de créer un thread est d'implémenter l'interface Runnable
class MonRunnable implements Runnable {

public void run() {
System.out.println("Mon Runnable est en cours d'exécution.");
}
Thread thread = new Thread(new MonRunnable());
thread.start();
}
}
COURS
Threads :Synchronisation EP&TP
193
[email protected]
Lorsque plusieurs threads accèdent à une ressource partagée, il peut y avoir des problèmes de
concurrence. Java fournit des mécanismes de synchronisation pour gérer cela.
Exemple avec synchronized method :
class Compteur {
private int compte;
public synchronized void

incrementer() {
compte++;
}
public int getCompte() {

return compte;
}
}
COURS EP&TP
wait(), notify(), et notifyAll() :
[email protected]
194 .
Ces méthodes sont utilisées pour la communication inter-thread
class Message {
private String message;
private boolean hasMessage = false;
public synchronized void attendre() throws

InterruptedException { public synchronized void envoyer(String
while (!hasMessage) { message) throws InterruptedException {
wait(); while (hasMessage) {
} wait();
hasMessage = false; }
notifyAll(); this.message = message;
return message; hasMessage = true;
} notifyAll();
}
}
Executor Framework
195
[email protected]
Plutôt que de gérer les threads manuellement, Java fournit le framework Executor qui facilite
la gestion des threads.
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
class MonRunnable implements Runnable {
public class Executor {
private String id;
ExecutorService executor =
public MonRunnable(String id) {
Executors.newFixedThreadPool(5);
this.id = id;
// crée un pool de 5 threads
}
for (int i = 0; i < 10; i++) {
public void run() {
Runnable worker = new
System.out.println("Mon Runnable avec
MonRunnable("" + i);
l'ID " + id +
executor.execute(worker); //
" est en cours d'exécution.");
démarre le thread
}
}
}
executor.shutdown(); // arrête les
threads une fois leur exécution terminée
}
}
COURS
[email protected]
EP24 EP&TP
196
1.Créez un thread qui imprime les nombres de 1 à 5 avec une pause d'une seconde entre chaque impression.
A
2.Créez un autre thread qui imprime les lettres de 'A' à 'E' avec une pause d'une seconde entre chaque
impression.
3.Lancez les deux threads pour voir leurs exécutions simultanées..
B Imaginez que vous avez une classe Counter avec une variable count.
Cette classe a deux méthodes, increment() et decrement(), qui augmentent et diminuent respectivement la valeur de
count.
1.Créez deux threads. L'un d'eux appelle la méthode increment() 50 fois, et l'autre appelle decrement() 50 fois.
2.Lancez les deux threads simultanément et observez le résultat.
3.Maintenant, synchronisez les méthodes increment() et decrement() pour éviter les problèmes de concurrence et
réexécutez les threads.
Utilisez les méthodes wait() et notify() pour gérer la communication entre deux threads.
C
1.Créez une classe Message qui contient une variable message de type String.
2.Créez un thread Writer qui attend 2 secondes, change la valeur de message, puis notifie un autre thread.
3.Créez un thread Reader qui attend que message soit mis à jour.
4.Lancez d'abord le thread Reader, puis le thread Writer.
COURS EP&TP
Date et Time
197
[email protected]
java.util.Date et java.util.Calendar :
Ce sont les classes originales pour représenter et manipuler des dates et des heures.
Date représente un instant précis dans le temps.
Calendar est une classe abstraite qui fournit des méthodes pour convertir entre un instant
précis et un ensemble de champs de calendrier tels que YEAR, MONTH, DAY_OF_MONTH, etc.
En raison de divers problèmes et limitations avec ces classes, Java a introduit de nouvelles API.
Date date = new Date();

System.out.println(date); // Date et heure actuelles
Calendar calendrier = Calendar.getInstance();

System.out.println(calendrier); LocalTime heureActuelle = LocalTime.now();
System.out.println(heureActuelle);
LocalDate dateAujourdhui = LocalDate.now(); // Heure actuelle
System.out.println(dateAujourdhui);
// Date actuelle LocalDateTime dateEtHeureActuelles =
LocalDateTime.now();
System.out.println(dateEtHeureActuelles);
// Date et heure actuelles
COURS EP&TP
Date et Time
198
[email protected]
Quelques classes clés de l'API Date/Time :
•LocalDate: représente une date sans heure ni

fuseau horaire.
//Ajouter 5 jours à la date actuelle :
•LocalTime: représente une heure sans date ni
LocalDate today = LocalDate.now();
fuseau horaire.
LocalDate futureDate = today.plusDays(5);
•LocalDateTime: représente une date et une heure
sans fuseau horaire.
//Calculer la différence entre deux dates :
•ZonedDateTime: représente une date et une
LocalDate date1 = LocalDate.of(2020, 1, 1);
heure avec un fuseau horaire.
LocalDate date2 = LocalDate.of(2023, 1, 1);
•Period: représente une durée en termes d'années,
Period period = Period.between(date1, date2);
mois et jours.
int years = period.getYears(); // 3
•Duration: représente une durée en termes de
secondes et de nanosecondes.
COURS EP&TP
[email protected]
EP25:
199
Vous développez une application qui permet aux utilisateurs de définir des rappels pour leurs tâches.
Pour cela, vous devez manipuler des dates et des heures.
1. Créez une classe Reminder qui a les attributs suivants :
•taskName (String) : le nom de la tâche.
•dateTime (LocalDateTime) : la date et l'heure du rappel.
2. Dans votre classe principale (par exemple, ReminderApp), créez une ArrayList pour stocker les rappels.
3. Créez une méthode pour ajouter un rappel.
Cette méthode prend le nom de la tâche et une chaîne de caractères représentant la date et l'heure au format dd-MM-
yyyy HH:mm
, et ajoute le rappel à la liste.
4. Créez une méthode qui imprime tous les rappels à venir dans les prochaines 24 heures.
5. Créez une méthode qui imprime tous les rappels passés.
6. (Bonus) Créez une méthode qui formate joliment l'affichage des rappels :
"Rappel : [Nom de la tâche] - [Date et heure au format 'dd-MM-yyyy HH:mm']".
COURS EP&TP
[email protected]
200
PARTIE 9 :
Initialisation Spring Boot
COURS EP&TP
Spring Boot
201
[email protected] Spring Boot est un framework open-source pour le développement d'applications Java qui vise à simplifier
la création et le déploiement d'applications Java. Il est basé sur le framework Spring, qui est également
très populaire dans le monde du développement Java.
COURS EP&TP
Caractéristiques de Spring Boot
202
[email protected]
1.Facilité de configuration : Spring Boot propose des conventions de configuration sensibles par défaut, ce qui signifie que
vous pouvez créer une application Spring Boot avec un minimum de configuration. Cela permet de réduire la quantité de
code de configuration nécessaire pour démarrer une application.
2.Intégration avec des serveurs embarqués : Spring Boot prend en charge l'intégration avec des serveurs Web embarqués tels
que Tomcat, Jetty ou Undertow. Vous pouvez donc créer des applications autonomes qui s'exécutent directement avec leur
propre serveur Web.
3.Dépendances prédéfinies : Spring Boot propose une liste de dépendances couramment utilisées pour différentes
fonctionnalités, comme l'accès aux données, la sécurité, les services web, etc. Vous pouvez les inclure dans votre projet en
spécifiant simplement les dépendances dont vous avez besoin, ce qui simplifie la gestion des dépendances.
4.Auto-configuration : Spring Boot inclut une fonctionnalité d'auto-configuration qui permet à l'application de se configurer
automatiquement en fonction des dépendances présentes dans le projet. Cela réduit considérablement le travail de
configuration manuelle.
5.Production-ready : Spring Boot intègre des fonctionnalités telles que la gestion des erreurs, la surveillance, la sécurité, les
journaux, etc., pour vous aider à créer des applications prêtes pour la production.
6.Développement rapide : En réduisant la configuration et en fournissant des outils et des fonctionnalités prêtes à l'emploi,
Spring Boot permet aux développeurs de créer rapidement des applications robustes.
7.Écosystème Spring : Spring Boot s'intègre parfaitement à l'écosystème Spring, ce qui signifie que vous pouvez utiliser les
fonctionnalités de Spring Framework, telles que Spring Data, Spring Security, Spring Cloud, etc., dans vos applications Spring
Boot
COURS EP&TP
Créer un Projet Hello World
203
[email protected]
1.Accédez à https://start.spring.io/
2.Configurez les options du projet comme suit :
•Project: Maven Project ou Gradle Project (choisissez celui que vous préférez).
•Language: Java.
•Spring Boot: La version la plus récente disponible.
•Group: Groupe de votre projet (par exemple, "com.example").
•Artifact: Nom de l'artifact (par exemple, "helloworld").
•Dependencies: Dans la zone de recherche, tapez "Web". Sélectionnez "Spring Web" pour inclure la dépendance
nécessaire pour créer une application web Spring Boot.
Vous pouvez également ajouter d'autres dépendances en fonction des besoins de votre projet.
3.Cliquez sur le bouton "Generate" ou "Generate Project" pour générer le projet.
4.Une archive ZIP contenant le projet sera téléchargée. Décompressez-la dans le répertoire de votre choix.
5.Ouvrez le projet dans votre environnement de développement intégré (IDE) préféré.
Si vous utilisez Eclipse, IntelliJ IDEA ou Visual Studio Code, vous pouvez importer le projet en tant que projet Maven ou Gradle,
en fonction de l'option que vous avez choisie à l'étape 2.
COURS EP&TP
204
[email protected]
Dans le projet généré, vous verrez une classe principale, généralement appelée Application.java,
qui contient une méthode main. Cette classe est l'entrée de votre application Spring Boot.
Pour créer un simple contrôleur "Hello World", vous pouvez créer une nouvelle classe Java dans le même
package que Application.java (ou ailleurs si vous le souhaitez).
Par exemple, vous pouvez créer un fichier HelloController.java avec le contenu suivant :
Démarrer l’application
ouvrez un navigateur Web et accédez à l'URL http://localhost:8080/hello
COURS EP&TP
205
[email protected]
Créer index.html dans ressources/static
Démarrer l’application
ouvrez un navigateur Web et accédez à l'URL http://localhost:8080/hello
COURS Application CRUD Spring EP&TP
206
[email protected] Suivez les étapes 1 à 4 du guide « Hello World » pour créer un nouveau projet Spring Boot.
Dans la section Dépendances, ajoutez ce qui suit : Spring Web pour les fonctionnalités Web. Spring
Data JPA pour la persistance des données. Base de données (nous utiliserons H2 pour plus de
simplicité).
Application CRUD Spring
Service:
207
[email protected] @Service
public class BookService {
Book Entity: @Autowired
private BookRepository bookRepository;
import jakarta.persistence.*;
public Book createBook(Book book) {
@Entity return bookRepository.save(book);
Repository
public class Book { }
@Id public List<Book> getAllBooks() {
@GeneratedValue(strategy = return bookRepository.findAll();
GenerationType.IDENTITY) }
private Long id; public Optional<Book> getBookById(Long id) {
private String title; return bookRepository.findById(id);
}
private String author;
public Book updateBook(Long id, Book book) {
if (bookRepository.existsById(id)) {
// Constructors, getters, book.setId(id);
setters... return bookRepository.save(book);
} }
Repository: return null;
}
public interface BookRepository extends public void deleteBook(Long id) {
JpaRepository<Book, Long> bookRepository.deleteById(id);
{ }
} }
COURS
[email protected]
Application CRUD Spring EP&TP
208 Contrôleur
@RestController
@RequestMapping("/books") Classe Main
public class BookController {
@Autowired @SpringBootApplication
private BookService bookService; public class Crud1Application {
@PostMapping
public Book createBook(@RequestBody Book book) {
public static void main(String[]
return bookService.createBook(book);
} args) {
@GetMapping
public List<Book> getAllBooks() { SpringApplication.run(Crud1Applicatio
return bookService.getAllBooks(); n.class, args);
} }
@GetMapping("/{id}") }
public Optional<Book> getBookById(@PathVariable Long id) {
return bookService.getBookById(id);
}
@PutMapping("/{id}")
public Book updateBook(@PathVariable Long id, @RequestBody Book book) {
return bookService.updateBook(id, book);
}
@DeleteMapping("/{id}")
public void deleteBook(@PathVariable Long id) {
bookService.deleteBook(id);
}
}
Configuration base donnée dans ressources/application.properties

209
[email protected]
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.h2.console.enabled=true
logging.level.org.springframework.boot=DEBUG
spring.jpa.hibernate.ddl-auto=update
Lancer le projet et accéder au navigateur par :

http://localhost:8080/books/
Tester les méthodes de CRUD avec insomnia ou postman :

210
[email protected]
COURS EP&TP
Application CRUD Spring FullStack
211
[email protected]  On modifie l’application précédente pour intégrer la partie Front-End:
@Controller  BookController.java
@RequestMapping("/books")
public class BookController {
@Autowired
private BookService bookService;
@GetMapping
public String listBooks(Model model) {
model.addAttribute("books", bookService.getAllBooks());
model.addAttribute("book", new Book());
return "books";
}
@PostMapping
public String addBook(@ModelAttribute Book book) {
bookService.createBook(book);
return "redirect:/books";
}
@GetMapping("/{id}")
public Optional<Book> getBookById(@PathVariable Long id) {
return bookService.getBookById(id);
}
COURS EP&TP
212
[email protected]
 Le suivant de BookController.java
@GetMapping("/edit/{id}")
public String editBookForm(@PathVariable Long id, Model model) {
Optional<Book> book = bookService.getBookById(id);
if (book.isPresent()) {
model.addAttribute("book", book.get());
model.addAttribute("books", bookService.getAllBooks());
return "books";
}
}
@PostMapping("/edit/{id}")
public String updateBook(@PathVariable Long id, @ModelAttribute Book book) {
bookService.updateBook(id, book);
}
@GetMapping("/delete/{id}")
public String deleteBook(@PathVariable Long id) {
bookService.deleteBook(id);
}
}
COURS EP&TP
213
[email protected]  On crée une page html dans ressources templates :Books.html
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
<title>Books</title>
</head>
<body>
<h1>Books</h1>
<form th:action="${book.id} ? @{/books/edit/{id}(id=${book.id})} : @{/books}"

th:object="${book}" method="post">
Title: <input type="text" th:field="*{title}" required />
Author: <input type="text" th:field="*{author}" required />
<input type="submit" th:value="${book.id} ? 'Update Book' : 'Add Book'" />
</form>
COURS EP&TP
[email protected]
214 <table>
<thead>
 Suivant de:Books.html <tr>
<th>ID</th>
<th>Title</th>
<th>Author</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
<tr th:each="book : ${books}">
<td th:text="${book.id}"></td>
<td th:text="${book.title}"></td>
<td th:text="${book.author}"></td>
<td>
<a th:href="@{'/books/edit/' + ${book.id}}">Edit</a>
<a th:href="@{'/books/delete/' + ${book.id}}">Delete</a>
</td>
</tr>
</tbody>
</table>
</body>
</html>
COURS Test de l’application EP&TP
215
[email protected] http://localhost:8080/books
TAF03
216
[email protected]
Réaliser l’application précédente avec Spring

Boot et la base de donnée MYSQL.
COURS EP&TP
[email protected]
217
PARTIE 10 :
Préparer les projets & examens
COURS EP&TP
Git
218
Git est un système de contrôle de version distribué qui permet aux développeurs de suivre les
[email protected]
changements dans leur code source au fil du temps.
Voici un aperçu des commandes Git courantes, de leurs rôles et de la façon dont elles
peuvent être utilisées dans le contexte d'un projet Java:
Initialiser un dépôt Git Cloner un dépôt existant

Commande: git init Commande: git clone [url]
Rôle: Initialiser un nouveau dépôt Rôle: Copier un dépôt Git existant à partir d'une URL
Git dans le répertoire courant. donnée.
mkdir MonProjetJava git clone
cd MonProjetJava https://github.com/username/MonProjetJava.git
git init
Valider des changements
Ajouter des fichiers au suivi de version Commande: git commit -m "[message]"
Commande: git add [fichier/dossier] Rôle: Enregistrer les changements dans le dépôt
Rôle: Ajouter des fichiers ou des répertoires au avec un message descriptif.
suivi de version. git commit -m "Ajout de la classe principale"
git add src/ MaClasse.java
COURS
[email protected]
Git EP&TP
219 Si vous faites référence à la connexion à GitHub (ou à d'autres plateformes Git) à l'aide
de votre e-mail, il est important de noter que vous ne pouvez pas directement utiliser
votre e-mail pour l'authentification lors d'opérations Git en ligne de commande.
Cependant, voici comment votre e-mail est généralement utilisé dans le contexte de
Git:
git config --global user.name "Votre Nom"
Lorsque vous configurez Git pour la première fois
git config --global user.email
sur votre machine, vous définissez votre nom et
"[email protected]"
votre e-mail. Ces informations sont utilisées pour
identifier l'auteur des commits.
ssh-keygen -t rsa -b 4096 -C
Utilisation de l'authentification par clé SSH:
"[email protected]"
a. Générez une nouvelle clé SSH si vous n'en
avez pas déjà une: Ajoutez votre clé SSH à l'agent SSH:
Cela générera une paire de clés dans ~/.ssh/, composée ssh-add ~/.ssh/id_rsa
d'une clé privée (id_rsa) et d'une clé publique
(id_rsa.pub). Copiez le contenu de votre clé publique (id_rsa.pub).
Vous pouvez le faire avec:
cat ~/.ssh/id_rsa.pub
Connectez-vous à votre compte GitHub, allez dans "Settings", cliquez sur "SSH and GPG keys", puis cliquez sur "New
SSH key". Donnez-lui un nom descriptif et collez la clé publique que vous avez copiée à l'étape précédente.
COURS EP&TP
[email protected] Git
220
#Ajouter une origine distante à un dépôt Git local :
Commande : git remote add [nom_du_remote] [url_du_dépôt]
Rôle : Ajouter une nouvelle origine distante à votre dépôt local. Cela permet à votre dépôt
local de savoir où se trouve le dépôt distant associé, afin que vous puissiez pousser et
tirer des changements.
Exemple :
git remote add origin https://github.com/username/MonProjet.git
Après avoir ajouté l'origine distante, vous pouvez vérifier qu'elle a été correctement
configurée en utilisant la commande suivante :
git remote –v
Cela affichera une liste de tous les remotes associés à votre dépôt local, y compris l'URL du
dépôt distant pour chaque remote. Si tout s'est bien passé, vous devriez voir quelque chose
comme ceci :
vous pouvez facilement pousser vos commits vers GitHub (ou tout autre service d'hébergement
de code) en utilisant git push origin [nom_de_la_branche], ou tirer les dernières
modifications avec git pull origin [nom_de_la_branche].
COURS EP&TP
[email protected]
Git
221
Tirer les changements d'un dépôt distant
Pousser des changements vers un dépôt distant Commande: git pull [remote] [branche]
Commande: git push [remote] [branche] Rôle: Récupérer les changements d'un dépôt distant et
Rôle: Envoyer les changements validés vers un les fusionner avec la branche
dépôt distant.
git pull origin main
git push origin master //ou main
Afficher l'état du dépôt Afficher l'historique des commits

Commande: git status Commande: git log
Rôle: Afficher l'état courant du dépôt, y compris les Rôle: Afficher un journal des commits,
fichiers modifiés et non suivis. montrant l'historique des modifications.
Changer de branche
Créer une nouvelle branche
Commande: git checkout [nom_branche]
Commande: git branch [nom_branche]
Rôle: Changer de branche.
Rôle: Créer une nouvelle branche.
git branch develop
Fusionner une branche git merge develop
Commande: git merge [nom_branche]
Rôle: Fusionner les changements d'une branche dans une autre.
COURS EP&TP
[email protected] Git/Github
222
# Fichiers compilés
Pour ajouter un projet Java (ou tout autre projet) à GitHub, vous *.class
pouvez suivre ces étapes: # Fichiers de package
*.jar
1. Créez un nouveau dépôt sur GitHub. *.war
2. Clonez ce dépôt sur votre machine locale. *.ear
3. Ajoutez votre code source Java à ce répertoire local. # Fichiers générés
4. Utilisez git add pour ajouter les fichiers à l'index. # automatiquement
5. Utilisez git commit pour valider les changements. *.log
6. Utilisez git push pour pousser les changements vers le dépôt GitHub. *.ctxt
7. N'oubliez pas d'ajouter un fichier .gitignore approprié pour Java afin # Dossier de build
d'éviter de suivre les fichiers inutiles (comme les fichiers compilés .class). target/
Voici un exemple de .gitignore pour un projet Java: # Autres fichiers/folders à
#ignorer
*.swp
*~
.#*
.DS_Store
COURS Git :dépôt privé EP&TP
[email protected]
223
Pour créer un dépôt privé et permettre à d'autres développeurs d'envoyer leurs
modifications, suivez ces étapes:
Étape 1: Créer un dépôt privé

Connectez-vous à votre compte GitHub.
Cliquez sur le bouton + en haut à droite de la page, puis sélectionnez "New repository".
Nommez votre dépôt.
Sélectionnez "Private" pour rendre le dépôt privé.
Cliquez sur "Create repository".
Étape 2: Donner accès à d'autres développeurs
Dans votre dépôt, cliquez sur l'onglet "Settings".
Dans le menu de gauche sélectionner Collaborateurs, puis cliquez sur "Manage access".
Cliquez sur le bouton vert "Invite teams or people".
Entrez le nom d'utilisateur ou l'adresse e-mail du développeur que vous souhaitez inviter.
Sélectionnez le niveau d'accès approprié pour le développeur:
Read: Le développeur peut voir et cloner le dépôt, mais ne peut pas pousser des
modifications.
Write: Le développeur peut pousser des modifications.
Maintain: Le développeur peut gérer le dépôt en plus des droits de lecture et d'écriture.
Admin: Le développeur a tous les droits sur le dépôt, y compris la suppression du dépôt.
Cliquez sur "Add" pour ajouter le développeur.
COURS EP&TP
[email protected] Git :dépôt privé

224
Étape 3: Les développeurs clonent et poussent leurs modifications

Une fois que vous avez donné accès à un développeur, il peut cloner le dépôt, apporter des
modifications localement, puis pousser ces modifications vers le dépôt GitHub.
Le développeur clone le dépôt:
git clone https://github.com/votre_nom_utilisateur/nom_du_dépôt.git
Après avoir apporté des modifications localement, le développeur peut ajouter, valider et pousser
ces modifications:
git add .
git commit -m "Description des modifications"
git push origin main
COURS EP&TP
Exemple Git dépôt privé: enseignant et étudiants

225
Si un enseignant souhaite que ses étudiants envoient leurs projets à un emplacement centralisé sur
GitHub, la meilleure approche serait d'utiliser un dépôt pour la classe et d'avoir des sous-dossiers pour
chaque étudiant ou projet. Voici comment cela pourrait être structuré et comment le mettre en place :
Étape 1: Créer un dépôt privé pour la classe

1. Connectez-vous à votre compte GitHub.
2. Cliquez sur le bouton + en haut à droite de la page, puis sélectionnez "New repository".
3. Nommez votre dépôt, par exemple "ProjetsClasse2023".
4. Sélectionnez "Private" pour rendre le dépôt privé.
5. Cliquez sur "Create repository".
Étape 2: Structurer le dépôt

Vous pouvez créer une structure de dossiers initiale pour organiser
les projets des étudiants. Par exemple :
Pour ce faire, vous pouvez ajouter cette structure directement via
l'interface web de GitHub ou la créer localement sur votre machine,
puis la pousser vers GitHub
[email protected]
COURS EP&TP
[email protected]
Exemple Git dépôt privé
226
Étape 3: Donner accès aux étudiants

1. Dans votre dépôt, cliquez sur l'onglet "Settings".
2. Dans le menu de gauche, cliquez sur "Manage access".
3. Cliquez sur le bouton vert "Invite teams or people".
4. Entrez le nom d'utilisateur ou l'adresse e-mail de chaque étudiant.
5. Sélectionnez le niveau d'accès "Write" pour que les étudiants puissent pousser leurs modifications.
6. Cliquez sur "Add" pour ajouter chaque étudiant.
Etape 4:Chaque étudiant clone le dépôt:

git clone https://github.com/votre_nom_utilisateur/ProjetsClasse2023.git
Etape 5:Les étudiants ajoutent leurs projets à leur sous-dossier cd ProjetsClasse2023

respectif, cd Etudiant1
par exemple : # Ajouter les fichiers du projet ici
git add .
Etape 6:Après avoir ajouté leurs projets, les étudiants
git commit -m "Projet de [NomEtudiant]"
peuvent pousser leurs modifications:
git push origin main
[email protected]
Exemple Git/Github :
227 2 développeurs collaborent
Voici un scénario typique pour deux développeurs, Alice et Bob, qui collaborent sur un projet Java.
Étape 1: Clonage du dépôt
Alice et Bob doivent d'abord cloner le dépôt sur leurs machines locales.
git clone URL_DU_DEPOT.git
cd NOM_DU_PROJET
Étape 2: Création d'une nouvelle branche
Avant de commencer à travailler sur une nouvelle fonctionnalité ou une correction, il est
recommandé de créer une nouvelle branche.
git checkout -b alice-feature
git checkout -b bob-feature
Étape 3: Écrire le code
Supposons qu'Alice et Bob ajoutent chacun une nouvelle classe Java.
Alice crée AliceClass.java et Bob crée BobClass.java.
Étape 4: Ajouter et valider les changements
Après avoir écrit leur code, Alice et Bob doivent ajouter et valider leurs changements.
git add AliceClass.java
git commit -m "Ajout de AliceClass"
git add BobClass.java
git commit -m "Ajout de BobClass"
[email protected] Exemple Git/Github :
228 2 développeurs collaborent
Étape 5: Pousser la branche vers le dépôt distant
Une fois leurs changements validés localement, Alice et Bob peuvent pousser leurs branches vers le dépôt
distant.
git push origin alice-feature
git push origin bob-feature
Étape 6: Éviter les conflits
Avant de fusionner leurs branches avec la branche main, Alice et Bob doivent s'assurer qu'il n'y a pas de
conflits. Pour ce faire, ils peuvent d'abord récupérer les derniers changements de la branche main.
git checkout main
git pull origin main
git checkout NOM_DE_LEUR_BRANCHE
git merge main
S'il y a des conflits, ils doivent être résolus manuellement. Une fois les conflits résolus, ils peuvent valider les
changements.
Étape 7: Fusionner la branche dans main
Après avoir résolu les conflits éventuels, Alice et Bob peuvent proposer leurs changements pour fusion dans la
branche main en utilisant une "pull request" (PR) sur la plateforme Git qu'ils utilisent (par exemple, GitHub,
GitLab, etc.). Une fois la PR revue et acceptée, elle peut être fusionnée avec la branche main.
COURS EP&TP
[email protected]
Git dépôt privé
229
Remarques importantes :
•Branching : Si vous vous inquiétez des conflits, vous pourriez enseigner à vos étudiants comment utiliser des
branches. Chaque étudiant pourrait créer sa propre branche, y apporter ses modifications, puis faire une "pull
request" pour que vous examiniez et fusionniez leurs changements.
•Taille du dépôt : Si vous vous attendez à de gros projets, le dépôt pourrait devenir assez volumineux. GitHub a
une limite pour la taille des dépôts. Si cela pourrait être un problème, envisagez d'utiliser des solutions comme
Git LFS (Large File Storage).
•Privé vs Public : Gardez à l'esprit que si le dépôt est privé, les étudiants ne pourront pas voir le travail des autres
à moins que vous ne leur donniez explicitement accès. Si la collaboration ou la revue par les pairs est souhaitée,
ajustez les permissions en conséquence.
•Protection des branches : Pour éviter que les étudiants ne modifient accidentellement le travail des autres, vous
pouvez envisager d'utiliser des "branch protections" dans les paramètres du dépôt.
COURS
TP05:Examen régional 2023 EP&TP
[email protected]
230
COURS TP05: Examen régional 2023 EP&TP
231
[email protected]
COURS TP06: Examen régional 2023 EP&TP
232
[email protected]
COURS EP&TP
TAF04
[email protected] [email protected]
233
Application de Gestion des Stagiaires - Filière Développement Digital
Objectif :
Développer une application pour gérer l'inscription, la sélection, le suivi académique et la progression des stagiaires dans la filière développement digital.
Fonctionnalités principales :
Inscription :
Les stagiaires peuvent s'inscrire entre le 1er juin et le 1er juillet.
Seuls les stagiaires ayant une note de bac >= 14 seront sélectionnés pour un entretien en prend en considération la sélection de 200% des stagiaire (le nombre
demandé est 40) .
Les stagiaires sélectionnés pour un entretien seront informés par email et SMS et l'entretien aura lieu entre le 20 et le 31 juillet.
40 stagiaires seront finalement sélectionnés et divisés en deux groupes : dev101 et dev102.
Gestion des Cours :
Les cours commencent le 09/09 et se terminent le 15 juin.
Chaque stagiaire étudie 30h par semaine, 5h par jour du lundi au samedi.
Les modules enseignés sont : M101 à M108, anglais, français, soft-skills, entrepreneuriat.
À la fin de chaque module, un examen est organisé. La note finale du module est calculée comme 75% de l'examen + 25% des contrôles (au moins 2 contrôles par
module).
Gestionnaire de Stagiaires :
Ajoute les stagiaires admis dans le système après validation de leur dossier d'inscription.
Suit les absences des stagiaires. Si un stagiaire a plus de 15 heures d'absence en une semaine, il est notifié. Si un stagiaire accumule plus de 60 heures d'absence, il est
éliminé.
Génère les relevés de notes pour S1 et S2.
Formateurs :
Ajoutent les notes des contrôles et de l'examen final de module.
Insèrent la masse horaire de chaque séance enseignée par jour. Lorsqu'un module atteint 100% de sa masse horaire, il est considéré comme achevé.
Progression des Stagiaires :
Si un stagiaire obtient une moyenne générale de 10/20 ou plus, il passe en 2ème année.
Les stagiaires choisissent une option en 2ème année : fullStack ou applications mobiles. Si une filière est très demandée, les stagiaires sont répartis en fonction de leurs
notes.
PAF01
234 [email protected]
Projets à faire.docx
COURS [email protected]
EP&TP
COURS
PAF02 EP&TP
[email protected]
235
Projets à réaliser avec Spring Boot en lien avec votre établissement (A vous de choisir le sujet)
Exemples des projets :
Gestion de la scolarité :Inscription des étudiants,Suivi des notes et des bulletins scolaires,Gestion des cours et des emplois du temps.
Solution de transport :Planification des itinéraires pour les étudiants,Gestion des abonnements de transport,Notification des retards
ou changements.
Gestion des absences :Enregistrement des absences et retards,Notification aux tuteurs ou responsables,Rapports
mensuels/trimestriels des absences.
Portail étudiant :Accès aux ressources pédagogiques,Forum de discussion entre étudiants et enseignants.Planning des événements et
activités extrascolaires.
Gestion financière :Suivi des paiements des frais de scolarité,Bourses et aides financières.Facturation et paiement en ligne.
Bibliothèque numérique :Catalogue en ligne des livres disponibles, Réservation et emprunt en ligne.
Système de recommandations basé sur les lectures.
Gestion des stages et des opportunités professionnelles :Offres de stage et d'emploi,Suivi des conventions de stage.Témoignages et
retours d'expérience.
Système de feedback et d'évaluation :Évaluations des cours par les étudiants.Suggestions d'améliorations.Classements des
enseignants basés sur les retours.
Communication et actualités :Diffusion des actualités et événements de l'établissement.
Système de newsletter pour les étudiants et parents.Calendrier des événements à venir.
COURS EP&TP
[email protected] Références:
236
• "Java: The Complete Reference" par Herbert Schildt.
• "Effective Java" par Joshua Bloch.
• "Head First Java" par Kathy Sierra & Bert Bates.
• Coursera : "Java Programming and Software Engineering Fundamentals" par l'Université Duke.
• Udemy : "Java Programming Masterclass for Software Developers" par Tim Buchalka.
• Codecademy : "Learn Java".
• Java Tutorials (Oracle's Official Documentation)
• Tutoriels Java officiels
• Java Code Geeks
• Développez.com

Java VF

Transféré par

Droits d'auteur :

Formats disponibles

Java VF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Java VF

Transféré par

Droits d'auteur :

Formats disponibles

DDOAM M201

Les principales différences entre une applet et une application sont :

Java a connu deux logos au cours de son histoire.

de 1996 à 2003 à partir de 2003

COURS Historique EP&TP

Java est sensible à la casse.

Pour exécuter le code :

java.applet Création d'applets

Les identifiants Java sont sensibles à la casse.

Exemple d'identifiants invalides :

Type de commentaires Exemple

// commentaire sur une seule ligne

commentaire multiligne /* commentaires ligne 1 commentaires ligne 2 */

Type Désignation Longueur Valeurs Commentaires

byte octet signé 8 bits -128 à 127

int entier signé 32 bits -2147483648 à 2147483647

float virgule flottante simple précision (IEEE754) 32 bits 1.401e-045 à 3.40282e+038

double virgule flottante double précision (IEEE754) 64 bits 2.22507e-308 à 1.79769e+308

Le format des nombres entiers :

Type Valeur par défaut

Un nombre quelconque de caractères de

La conversion peut entrainer Classe Rôle

28 Java propose des opérateurs pour toutes les comparaisons :

Opérateur Exemple Signification

ET logique (pour expressions booléennes) : l'évaluation de l'expression cesse dès qu'elle

OU logique (pour expressions booléennes) : l'évaluation de l'expression cesse dès qu'elle

opérateur conditionnel : renvoie la valeur b ou c selon l'évaluation de l'expression a (si a

B.Switcher deux variables en utilisant une 3eme variable.

C.Déclarez deux variables entières, a et b. Attribuez à a la valeur 10 et à b la valeur 20.

D.Déclarez une variable pi de type double et attribuez-lui la valeur 3.141592653589793. Ensuite,

E.Déclarez une variable double nommée nombre avec la valeur 10.5.

F.Déclarez deux variables entières x et y. Attribuez à x la valeur 15 et à y la valeur 4.

'instruction if permet d'exécuter l'instruction ou

L'instruction switch permet d'exécuter du code selon

do { // ... } while ( boolean );

Java 1.5 propose une nouvelle syntaxe pour les boucles

L'utilisation de la syntaxe de l'instruction for évouée peut

B. Créez une boucle qui affiche les nombres de 5 à 1 en utilisant la décrémentation.

D.Écrivez un programme qui demande à l'utilisateur de saisir un nombre positif.

G.Écrivez un programme Écrivez un programme

2.Améliorer le programme précédant afin de lire l'entier n, lors de l'exécution du programme.

Il est ainsi possible d'enchaîner plusieurs méthodes :

StringBuilder en String pour l'affichage

Les principales méthodes de la classe Throwable sont :

E.Calculer la longueur d’un coté de triangle en utilisant théorie de Vitagorsse.Les entrées A et B ?

L'initialisation explicite d'un tableau

C.Écrivez un programme qui inverse le contenu d'un tableau d'entiers.

F.Déclarer les deux tableaux suivants en Java :

les méthodes des listes spécifiques offrent des opérations

1. Demandez à l'utilisateur combien d'étudiants il souhaite ajouter.

➢ Une classe est le support de l'encapsulation : c'est un

la classe contient une ou des méthodes abstraites, qui n'ont pas de

la classe ne peut pas être modifiée, sa redéfinition grâce à l'héritage est

Si une méthode ou une variable est déclarée protected, seules les

➢ Les objets contiennent des attributs et des méthodes.

L'opérateur new se charge de créer une instance de la classe et de l'associer à la variable

L'opérateur instanceof permet de

les varargs permettent de passer un nombre non défini

La définition d'un constructeur est facultative.