Java EE Partie 1

OBJECTIFS DU COURS
 Décrire les éléments-clé de la plate-forme Java
 Compiler et exécuter une application Java
 Comprendre et utiliser la documentation en ligne de Java
 Décrire la syntaxe du langage
 Comprendre le paradigme OO et utiliser Java pour le mettre en œuvre
 Comprendre et utiliser les exceptions
 Développer un programme qui utilise une interface graphique pour introduire les données à
traiter
 Comprendre la gestion des événements
 Développement des applets

JAVA COMME PLATEFORME
Plateforme = environnement hardware ou software sur

lequel le programme est exécuté.
 La « Java Platform » est constituée de :
• La « Java Virtual Machine » (JVM)
• Des interfaces de programmation d’application (Java API)
2
JAVA COMME LANGAGE DE PROGRAMMATION
Le compilateur Java génère un bytecode, c’est à dire un

format intermédiaire, neutre architecturalement, conçu pour
faire transiter efficacement le code vers des hardware
différents et/ou plateformes différentes
Le bytecode ne peut-être interprété que par le processeur de
la JVM
3
DÉPLOIEMENT D’UN PROGRAMME CLASSIQUE DE LA COMPILATION
4
DÉPLOIEMENT D’UN PROGRAMME
CHANGEMENT DE LA VISION TRADITIONNELLE DE LA COMPILATION
Chaque programme est compilé et interprété

« Write once run everywhere »
5
JAVA ET SES VERSIONS
Quelques versions de la Machine Virtuelle

• Java 2 Micro Edition (Java ME): cible les terminaux
portables.
• Java 2 Standard Edition (Java SE) : cible les postes
clients.
• Java 2 Entreprise Edition (Java EE) : définit le cadre
d’un serveur d’application.
Différentes finalités
• SDK (Software Development Kit) : fournit un
compilateur et une machine virtuelle.
• JRE (Java Runtime Environment) : fournit
uniquement une machine virtuelle. Idéal pour le
déploiement de vos applications.
6
II. PREMIÈRE APPLICATION EN
JAVA
COMMENT DÉVELOPPER UNE APPLICATION?
Deux façons d’écrire des programmes Java:

En écrivant le code dans un simple éditeur de texte
 Compilation et exécution du code en ligne de commande DOS
En utilisant un environnement de développement (IDE)

 Netbeans (http://www.netbeans.com)
 Eclipse (https://www.eclipse.org/downloads/)
 Borland JBuilder (http://www.borland.com/jbuilder)
…
UNE PREMIÈRE APPLICATION
APPLICATION VERSUS APPLET

Une application Java
 est composée d’une classe possédant une méthode main() :
public static void main (String[] args){
//code à exécuter pour initialiser l’application
}
 L’environnement d’exécution dépend de l’OS de la machine
 Pas de restriction au niveau des API
Une applet Java

 Comprend une classe publique dérivant de java.applet.Applet
 L’environnement d’exécution dépend du browser Web
 Restrictions au niveau des API
 Généralement pas autorisée à lire ou écrire sur des fichiers locaux.
 Interdiction d’ouvrir des connections réseaux vers d’autres systèmes que la machine hôte qui a chargé l’applet
 …
INSTRUCTIONS
• Les instructions Java se terminent par un ;

• Les blocs sont délimités par
{ pour le début de bloc
} pour la fin du bloc
Un bloc permet de définir un regroupement d’instructions. La définition
d’une classe ou d’une méthode se fait dans un bloc.
• Sauts de ligne, les espaces et les tabulations sont autorisés. Cela permet de
présenter un code plus lisible.
POINT D’ENTRÉE D’UN PROGRAMME JAVA
Pour pouvoir faire un programme exécutable, il faut toujours une

classe contenant une méthode particulière, la méthode « main ».
– C’est le point d’entrée dans le programme : le

microprocesseur sait qu’il va commencer à exécuter les
instructions à partir de cet endroit.
public static void main(String args[ ])

{
…/…
}
APPLICATION BONJOUR LE MONDE
Créer un fichier texte : Bonjour.java

Règle de bonne pratique : 1 classe par fichier et 1 fichier par classe
public class Bonjour La première ligne du programme doit être la

déclaration de la classe
{
public static void main (String[]args) Tout programme doit contenir une méthode
{ main qui porte la signature ci-contre
System.out.println(« Bonjour le monde"); Écrire à l’écran “Bonjour le monde”
}
}
Fermer les accolades
· Compiler le programme : javac Bonjour.java

· Le compilateur génère le bytecode dans le fichier : Bonjour.class
· Exécuter l’application : java Bonjour
· « Bonjour le monde » s’affiche à l’écran
IDENTIFICATEURS
• On a besoin de nommer les classes, les variables, les constantes, etc. ;

on parle d’identificateur.
• Les identificateurs commencent par une lettre, _ ou $
Attention : Java distingue les majuscules des minuscules .
• Conventions sur les identificateurs :
 La première lettre est majuscule pour les classes et les interfaces.
 exemples : MaClasse
 La première lettre est minuscule pour les méthodes, les
attributs et les variables.
• exemples : getLongueur(), i
 Les constantes sont entièrement en majuscules.
• exemple : HAUTEUR_MAX
COMMENTAIRES DANS LE CODE SOURCE
Java dispose de trois formes de commentaires :

 Tout texte entre « // » et la fin de la ligne
// Commentaires sur une seule ligne
 Tout texte entre « /* » et « */ »

/* Commentaires
sur un nombre très important
de lignes */
 Les textes entre « /** » et « */ » sont utilisés pour créer des commentaires que l’exécutable
JAVADOC pourra traiter afin de produire une documentation
/** Commentaires afin de produire
la documentation */
LES MOTS RÉSERVÉS DE JAVA
abstract default goto null synchronized
boolean do if package this
break double implements private throw
byte else import protected throws
case extends instanceof public transient
catch false int return true
char final interface short try
class finally long static void
continue float native super volatile
const for new switch while

TYPES PRIMITIFS ET TYPES DE RÉFÉRENCE
Java est un langage fortement typé

Le type de données précise
 les valeurs que la variable peut contenir
 les opérations que l’on peut réaliser dessus
Deux types de données:

 Donnée primitive: contient physiquement la valeur
(caractère, nombre, booléen)
 Référence: contient l’adresse mémoire où l’information relative à l’objet,
l’interface, etc. est réellement stockée
Référence: Adresse
TYPES DE DONNÉES PRIMITIFS (1/4)
P rim itive Da ta T yp es
In teg ral F lo ating
b yte 8 bits -12 8 to 1 27 flo at 3 2b its 1 .4 E-4 5 3 .4E 38

sh ort 1 6 bits -3 27 68 to 3 27 67 d o ub le 6 4b its 4 .9 E -3 2 4 1.8 E3 08
in t 3 2 bits -2^3 1 to 2 ^31 -1
lo n g 6 4 b its -2^6 3 to 2 ^63 -1
T e xtu al L o g ical
ch ar 16 b its 0 to 6 55 35 o n e b it : tru e o r fa lse

Explication:
 byte : codé sur 8 bits  28 valeurs  (–27) to (27–1) = -128 à 127
 int : codé sur 32 bits  232 valeurs  (–231) to (231–1)
Déclaration et initialisation :
 int int x=12;
 short short x= 32;
 long long x= 200L; // Nombre accolé à un L
 byte byte x=12;
 double double x=23.2323;
 float float x= 23.233F; // Nombre accolé à un F
 char char c=‘a’;
 boolean boolean b=true;
Déclaration, Initialisation et Assignation des types primitifs
int t; Déclaration d’un entier t (t est l’identificateur)

int u = 3; Déclaration et initialisation d’un entier
t=7; Initialisation de t à la valeur 7
u=t; Assignation (affectation) de la valeur de t à u
m=9; Erreur déclaration préalable nécessaire
char c; Déclaration
c=‘a’; Initialisation
Exemple:
Déclaration et initialisation de 2 entiers: a et b

int a = 5;
int b = 8;
Affectation de la valeur de b à a
a=b;
Désormais, il existe deux variables en mémoire qui ont la

même valeur
a=8 b=8
TYPES DE RÉFÉRENCE
Tous les types hormis les types primitifs

« Pointeur implicite » sur un objet
Référence: Adresse
PORTÉE D'UNE VARIABLE
La portée d'une variable va de la ligne de sa définition jusqu'à la fin du bloc dans

lequel elle est définie.
Exemple
{
int n=10;
…
{
int p=20;
float n=3.5; //erreur de compilation : définition de n invalide. …
}
System.out.println("p = " + p); //erreur de compilation : p inconnu
}
ARITHMÉTIQUE ET OPÉRATEURS
ARITHMÉTIQUE ÉLÉMENTAIRE
Quelle est la valeur de : 5+3*4+(12/4+1)

Règles de précédences sur les opérateurs:
Niveau Symbole Signification
1 () Parenthèse
* Produit
2 / Division
% Modulo
+ Addition ou concaténation
3
- Soustraction
OPÉRATEURS DE COMPARAISON
Pour comparer deux valeurs:

Opérateur Exemple Renvoie TRUE si
> v1 > v2 v1 plus grand que v2
>= v1 >= v2 Plus grand ou égal
< v1 < v2 Plus petit que
<= v1 <= v2 Plus petit ou égal à
== v1 == v2 égal
!= v1 != v2 différent
Opérateur Usage Renvoie TRUE si

Opérateurs logiques:
&& expr1 && expr2 expr1 et expr2 sont vraies
& expr1 & expr2 Idem mais évalue toujours les 2 expressions
|| expr1 || expr2 Expr1 ou expr2, ou les deux sont vraies
| expr1 | expr2 idem mais évalue toujours les 2 expressions
! ! expr1 expr1 est fausse
!= expr1 != expr2 si expr1 est différent de expr2
ARITHMÉTIQUE ET OPÉRATEURS
OPÉRATEURS D’ASSIGNATION (D’AFFECTATION)
L’opérateur de base est ‘=‘

Il existe des opérateurs d’assignation qui réalisent à la fois
 une opération arithmétique, logique, ou bit à bit
 et l’assignation proprement dite
Opérateur Exemple Équivalent à
+= expr1 += expr2 expr1 = expr1 + expr2
-= expr1 -= expr2 expr1 = expr1 – expr2
*= expr1 *= expr2 expr1 = expr1 * expr2
/= expr1 /= expr2 expr1 = expr1 / expr2
%= expr1 %= expr2 expr1 = expr1 % expr2

STRUCTURES DE CONTRÔLE
• Les structures de contrô le classiques existent en Java :
 if, else
 switch, case, default, break
 for
 while
 do, while
Structure if
if (expression logique) instruction;
if (expression logique)
{ instruction; instruction;
...
}
Structure if else
if (expression logique) instruction;
else instruction;
if (expression logique)
...
}
else
...
}
Boucle for
for (initialisation; condition ; incrémentation ou décrémentation)

{
instruction_1;
instruction_2;
...
instruction_n;
}
Boucle while
while (expression
booléenne)
{
instruction_1;
instruction_2;
...
instruction_n;
Boucle do while
do
{
instruction_1;
instruction_2;
...
instruction_n;
} while (condition);
Exemple: calcul de la somme des dix premiers entiers positifs.
public class Counter {

public static void main (String args[]){ int
somme=0, indice=1;
do{
somme += indice;
Indice++;
} while (indice<=10) ;
String str= "La somme des dix premiers entiers positifs est : ";
System.out.println(str + somme);
}}
L’instruction switch : sélectionne un morceau de code parmi d'autres

en se basant sur la valeur d'une expression entière
switch (variable){
case valeur1 : instructions1 ;
case valeur2 : instructions2 ;
…
default : instructions ;
}
Exemples:
int choix=2;
switch(choix){
case 1: System.out.println("Bonjour");
break;
case 2: System.out.println("Hello");
break;
case 3: System.out.println("Buenos
dias"); break;
default: System.out.println("Choix
incorrect"); break;
}
L’instruction break : Permet de terminer l’exécution d’une boucle.
Exemple :// Impression des nombres premiers entre 2 et 100.

int n = 100;
boolean premier;
for (int i = 2; i <= n; i++)
{
premier = true;
for (int j = 2; j < i; j++)
{
if (i % j == 0)
{
premier
=
f
a
l
s
e
;
L’instruction continue : permet l’interruption d’une itération en

cours et retourne au début de la boucle avec exécution de la partie
incrémentation.
Exemple : la somme des entiers impairs.
int somme = 0;
for (int i = 0; i < 100; i++)
{
if (i % 2 == 0) continue;
somme += i;
}
Quels résultats fournit le programme suivant ?

public class Test {
public static void main(String[] args) {
int n=0 ;
do {
if (n%2==0) {
System.out.println (n + " est pair") ;
n += 3 ;
continue ;
}
if (n%3==0) {
System.out.println (n + " est multiple de 3") ;
n += 5 ;
}
if (n%5==0) {
System.out.println (n + " est multiple de 5") ;
break ;
}
n += 1 ;
} while (true) ;
}
}
LECTURE D’INFORMATIONS AU CLAVIER
 Pour la saisie de données au clavier, on va utiliser la classe Scanner

(java.util.Scanner) qui regroupe plusieurs méthodes pratiques :
 nextInt(),
 nextDouble(),
 nextFloat(),
 nextLong(),
 nextLine(),
 …
Exemple:
public class AfficheEntier{
Scanner sc=new Scanner(System.in);//System.in: Entrée Standard
System.out.println("Entrer un entier:");
int a=sc.nextInt();
System.out.println(" le nombre entré est :" + a);
}}
En résumé
• L’affichage des données se fait par System.out.println ().
• La lecture des entrées clavier se fait via l'objet Scanner.
•Ce dernier se trouve dans le package java.util que vous devez

importer.
•Pour pouvoir récupérer ce que vous allez taper dans la console, vous
devrez initialiser l'objet Scanner avec l'entrée standard, System.in.
•Il y a une méthode de récupération de données pour chaque type :

nextLine() pour les String, nextInt() pour les int ...
EXERCICES
Quels résultats fournit ce programme ?

public class Test{
public static void main (String args[])
{
int i=10, j=5 ;
if (i<5 && j++<10) System.out.println ("&&1 vrai") ;

else System.out.println ("&&1 faux") ;
System.out.println ("i = " + i + " j = " + j) ;
if (i<5 & j++<10) System.out.println ("& vrai") ;

else System.out.println ("& faux") ;
if (i<15 && j++<10) System.out.println ("&&2 vrai") ;

else System.out.println ("&&2 faux") ;
if (i<15 || j++<10) System.out.println ("|| vrai") ;

else System.out.println ("|| faux") ;
}
}
EXERCICES
Soit le programme suivant: import java.util.Scanner;

import java.util.Scanner; public class Test{
public class Test{ public static void main (String args[])
public static void main (String args[]) {
{
int i, n, som ; int i, n, som ;
som = 0 ;
som = 0 ;
Scanner sc=new Scanner(System.in);
Scanner sc=new Scanner(System.in); i=0;
for (i=0 ; i<4 ; i++) while (i<4)
{ {
System.out.println ("donnez un entier ") ; System.out.println ("donnez un entier ") ;
n = sc.nextInt() ; n = sc.nextInt() ;
som += n ; som += n ;
} i++;
System.out.println ("Somme : " + som) ; }
System.out.println ("Somme : " + som) ;
}
}
} }
Écrire un programme réalisant la même chose en
employant à la place de l’instruction for une instruction
while
JAVA/TABLEAUX
Un tableau est un ensemble indexé de données d'un même type. L'utilisation

d'un tableau se décompose en trois parties :
 Création du tableau
 Remplissage du tableau
 Lecture du tableau.
JAVA/TABLEAUX
Création d'un tableau
Un tableau se déclare et s'instancie comme une classe :

int monTableau[ ] = new int[10];
ou
int [ ] monTableau = new int[10];
L'opérateur [ ] permet d'indiquer qu'on est en train de déclarer un tableau.
Si [ ] suit le type, toutes les variables déclarées seront des tableaux, alors que si [ ] suit le nom de
la variable, seule celle-ci est un tableau :
int [] premierTableau, deuxiemeTableau;

float troisiemeTableau[], variable;
Dans ces quatre déclarations, seule variable n'est pas un tableau.

JAVA/TABLEAUX
Remplissage d'un tableau
Une fois le tableau déclaré et instancié, nous pouvons le remplir :

int [] monTableau = new int[10];
monTableau[5] = 23;
L'indexation démarre à partir de 0, ce qui veut dire que, pour un tableau de N éléments, la
numérotation va de 0 à N-1.
Dans l'exemple ci-dessus, la 6ème case contient donc la valeur 23.
Nous pouvons également créer un tableau en énumérant son contenu :
int [] monTableau = {5,8,6,0,7};
Ce tableau contient 5 éléments.

Lorsque la variable est déjà déclarée, nous pouvons lui assigner d'autres valeurs en utilisant
l'opérateur
new :
monTableau = new int[]{11,13,17,19,23,29};

JAVA/TABLEAUX
Lecture d'un tableau

Pour lire ou écrire les valeurs d'un tableau, il faut ajouter l'indice entre crochets ([ et ]) à la suite du
nom du tableau :
int [] monTableau = {2,3,5,7,11,23,17};
int nb;
monTableau[5] = 23; // -> 2 3 5 7 11 23 17
nb = monTableau[4]; // 11
L'indice 0 désigne le premier élément du tableau.
L'attribut length d'un tableau donne sa longueur (le nombre d'éléments).
Donc pour un tableau nommé monTableau l'indice du dernier élément est monTableau.length-1.
Ceci est particulièrement utile lorsque nous voulons parcourir les éléments d'un tableau.
for (int i = 0; i < monTableau.length; i++) {
int element = monTableau[i]; // traitement

}
INTRODUCTION À LA
PROGRAMMATION
ORIENTÉE OBJET
42
DE LA PROGRAMMATION CLASSIQUE VERS LA
PROGRAMMATION ORIENTÉE OBJET
La programmation classique telle que étudiée au travers des langages C,

Pascal… définie un programme comme étant:
 un ensemble de données sur lesquelles agissent des procédures et des
fonctions.
Les données constituent la partie passive du programme. Les procédures et
les fonctions constituent la partie active;
 Programmer dans ce cas revenait à:

définir un certain nombre de variables (structures, tableaux…)
écrire des procédures pour les manipuler sans associer explicitement les
unes aux autres.
43
Exécuter un programme se réduit alors à appeler ces procédures dans

un ordre décrit par le séquençage des instructions et en leur fournissant
les données nécessaires à l’accomplissement de leurs tâches.
44
 Un programme est constitué d’un ensemble d’objets chacun disposant

d’une partie procédures et d’une partie données. Les objets interagissent par
envoie de messages.
Un objet peut recevoir un msg qui déclenche:
Une fonction qui modifie son état.
Une fonction qui envoie un msg à un autre objet.
45
CLASSES ET OBJETS
Classe : Une classe c’est la description d’un ensemble d’objets ayant

une structure de données commune et disposant des mêmes méthodes.
c'est un ensemble de données et de fonctions regroupées dans une
même entité
Exemple
46
CLASSES ET OBJETS
Objet : Un objet est une structure informatique caractérisée par un

état et un ensemble d'opérations exécutables par cet objet qui
caractérise son comportement.
Objet = état + comportement (opérations)
Exemple
47
CLASSES ET OBJETS
Classe Instances
-Nom : hariri
-Prenom :nabil
-Age :25
Instanciation
-Nom :ibrahimi
-Prenom :nawal
-Age :22
48
CLASSES ET OBJETS(SYNTAXE DE DÉCLARATION D’UNE
CLASSE)
La syntaxe de déclaration d'une classe est la suivante :

modificateurs class nom_de_classe [extends classe_mere] [implements interfaces] { ... }
Les modificateurs de classe (ClassModifiers) sont :
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 abstract ne peut pas être instanciée : 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

final grâce à l'héritage est interdite. Les classes déclarées
final ne peuvent donc pas avoir de classes filles.
public La classe est accessible partout
49
CLASSES ET OBJETS
Syntaxe de déclaration d’une classe est :
public class Nom_de_la_classe

{
type p1; //
propriété p1 type p2; Attributs
// propriété p2
…
type m1(…){ // méthode
m1
… Méthodes
type m2(…){ //} méthode m2
…
}
…
}
50
CRÉATION D'UN OBJET : INSTANCIER UNE
CLASSE
Il est nécessaire de définir la déclaration d'une variable ayant le type de

l'objet désiré. La déclaration est de la forme:
nom_de_classe nom_de_variable
Exemple
MaClasse m;
String chaine;
L'opérateur new se charge de créer une instance de la classe et de l'associer à la variable

m = new MaClasse();
Il est possible de tout réunir en une seule déclaration:
MaClasse m = new MaClasse();
51
CLASSE
 En Java, tous les objets sont instanciés par allocation dynamique. Dans
l'exemple, la variable m contient une référence sur l'objet instancié (contient
l'adresse de l'objet qu'elle désigne : attention toutefois, il n'est pas possible de
manipuler ou d'effectuer des opérations directement sur cette adresse comme
en C.
 Si m2 désigne un objet de type MaClasse, l'instruction m2 = m ne définit pas un
nouvel objet mais m et m2 désignent tous les deux le même objet.
 L'opérateur new est un opérateur de haute priorité qui permet d'instancier des
objets et d'appeler une méthode particulière de cet objet : le constructeur. Il fait
appel à la machine virtuelle pour obtenir l'espace mémoire nécessaire à la
représentation de l'objet puis appelle le constructeur pour initialiser l'objet dans
l'emplacement obtenu. Il renvoie une valeur qui référence l'objet instancié.
 Si l'opérateur new n'obtient pas l'allocation mémoire nécessaire, il lève
l'exception OutOfMemoryError.
52
CLASSE
Remarque sur les objets de type String : un objet String est automatiquement
créé lors de l'utilisation d'une constante chaîne de caractères sauf si celle-ci
est déjà utilisée dans la classe. Ceci permet une simplification lors de la
compilation de la classe.
53
CRÉATION D'UN OBJET :
INSTANCIER UNE CLASSE
Pour obtenir une seconde instance de la chaine, il faut explicitement demander sa création en
utilisant l'opérateur new.
les tests réalisés dans ces deux exemples sont réalisés sur les références des
instances. Pour tester l'égalité de la valeur des chaînes, il faut utiliser la méthode
equals() de la classe String.
54
DURÉE DE VIE D'UN OBJET
Les objets ne sont pas des éléments statiques et leur durée de vie ne
correspond pas forcément à la durée d'exécution du programme.
La durée de vie d'un objet passe par trois étapes :
 La déclaration de l'objet et l'instanciation grâce à l'opérateur new.
 L'utilisation de l'objet en appelant ses méthodes
 La suppression de l'objet : elle est automatique en Java grâce à la machine
virtuelle. La restitution de la mémoire inutilisée est prise en charge par le
récupérateur de mémoire (garbage collector). Il n'existe pas d'instruction
delete comme en C++.
55
RÉFÉRENCES ET LA COMPARAISON D'OBJETS
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 :
Exemple :
Rectangle r1 = new Rectangle(100,50);

Rectangle r2 = new Rectangle(100,50);
if (r1 == r1) { ... } // vrai
if (r1 == r2) { ... } // faux
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:
(obj1.getClass().equals(obj2.getClass())
56
LES VARIABLES DE CLASSES
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.
Exemple :
public class MaClasse() {
static int compteur = 0;
}
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.
MaClasse m = new MaClasse(); Ce type de variable est utile
int c1 = m.compteur; pour, par exemple, compter
le nombre d'instanciations
int c2 = MaClasse.compteur; de la classe.
// c1 et c2 possèdent la même valeur. 57
LA VARIABLE THIS
Cette variable sert à référencer dans une méthode l'instance de l'objet en
cours d'utilisation. this est un objet qui est égal à l'instance de l'objet dans
lequel il est utilisé.
class MaClasse() {
String chaine = " test " ;
public String getChaine() { return chaine; }
// est équivalent à public String getChaine() { return
this.chaine; }
}
Il est préférable de préfixer la variable d'instance par le mot clé this.
this.nombre = nombre;
Cette référence est habituellement implicite :
private int nombre;
public maclasse(int nombre) {
nombre = nombre;
} 58
OPÉRATEUR INSTANCEOF
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
void testClasse(Object o) {
if (o instanceof MaClasse )
System.out.println(" o est une instance de la classe MaClasse ");
else System.out.println(" o n'est pas un objet de la classe MaClasse ");
}
59
OPÉRATEUR INSTANCEOF
même si o est une instance de MaClasse, il n'est pas permis d'appeler une
méthode de MaClasse car o est de type Objet.
void afficheChaine(Object o) {
if (o instanceof MaClasse)
System.out.println(o.getChaine());
// erreur à la compil car la méthode getChaine()
//n'est pas définie dans la classe Object
}
Pour résoudre le problème, il faut utiliser la technique du casting (conversion).
void afficheChaine(Object o) {
if (o instanceof MaClasse) {
MaClasse m = (MaClasse) o;
System.out.println(m.getChaine());
}
} 60
ENCAPSULATION
• L’encapsulation consiste à réduire la visibilité des attributs et des

méthodes d'une classe, afin de n'exposer que les fonctionnalités
réellement nécessaires pour les classes utilisatrices.
61
LES MOTS CLÉS QUI GÈRENT LA VISIBILITÉ DES ENTITÉS
Quand vous définissez des membres dans une classe, vous avez le
choix parmi quatre niveaux de visibilité. Trois de ces niveaux (public,
protected et private) sont associés à des mots clés. Le quatrième
niveau s'obtient en ne spécifiant aucune mot clé relatif à la visibilité.
62
LA VISIBILITÉ PUBLIQUE - PUBLIC
Si vous définissez un membre (attribut, méthode...) public il sera alors

accessible de n'importe ou dans le programme. La classe aura donc accès à
ce membre, mais aussi n'importe quelle autre classe.
public class Demo {

public int attribute = 10;
public void doSomething() {
System.out.println( "Do something" );
}
}
63
LA VISIBILITÉ PROTÉGÉE - PROTECTED
Un membre marqué dans une classe comme étant protégé (mot clé
protected) peut être manipulé :
1. Dans la classe qui définit ce membre,

2. Dans les classes qui dérivent de la classe considérée,
3. Et dans toutes les classes (et les types) définies dans le même
package que celle qui définit le membre protégé.
64
LA VISIBILITÉ « PACKAGE PRIVATE »
En l'absence de mot clé pour spécifier la visibilité, un membre sera considéré comme
étant « package private » (on peut simplifier en parlant de visibilité package). C'est
donc le mode de visibilité par défaut (absence de mot clé). Cela veut dire que le
membre sera accessible par tout code Java localisé dans le même package. Voici un
exemple d'utilisation.
package cours.exemple;
public class TestVisibilite {
public int attr1 = 10;
protected int attr2 = 20;
int attr3 = 30; // Visibilité package private !
private int attr4 = 40;
}
Si une autre classe du même package essaye d'utiliser la classe TestVisibility,

elle aura accès aux membres de type « package private » (mais aussi aux
membres protégés et publics). 65
LA VISIBILITÉ PRIVÉE - PRIVATE
Dans ce cas, seule la classe ayant définit le membre pourra y accéder.

package cours.exemple;
public class Demo {
private static int privateAttribute = 10;
public static void main( String [] args ) {
System.out.println( "J'ai accès à l'attribut static privé : "
+ privateAttribute );
}
}
66
EXEMPLE CLASSES ET OBJETS (1)
public class Point{

private int x ; // abscisse
Attributs
private int y ; //
ordonnee
public void initialise (int abs, int ord)
{ x = abs ;
y=
} ord ;
public void deplace (int dx, int dy)
{ x += dx ;
y += Méthodes
dy ;
}
public
void
affiche ()
}{ System. 67
EXEMPLE CLASSES ET
OBJETS (2)
Méthodes ou fonctions membres: la définition d’une méthode
se compose d’un en-tête et d’un bloc.
public void initialise (int abs, int ord) En-tête

{ x = abs ;
y= Bloc
} ord ;
Remarque : L’ordre des méthodes dans une classe n’a pas

d’importance. Par exemple dans la classe Point on peut déclarer la
méthode affiche() puis la méthode deplace(), affiche() peut être
appelée sans problème dans deplace().
EXEMPLE CLASSES ET
OBJETS (3)
Utilisation d'une classe : Pour pouvoir utiliser une classe il faut
d’abord déclarer un objet, la déclaration est réalisée de la manière
suivante :
NomDeClasse NomDeVariable ;
Point a ;
//cette déclaration ne réserve pas d’emplacement pour un objet de type Point,

//mais seulement un emplacement pour une référence à un objet de type Point.
Exemple Classes et Objets (4)
Pour créer une instance d’une classe, il faut utiliser l’opérateur new qui
se charge de créer une instance (ou objet) de la classe et de l’associer à
la variable. L’instanciation est réalisée par la façon suivante :
NomDeVariable = new NomDeClasse() ;
crée un emplacement pour un objet de type Point et

a = new Point() ;
fournit sa référence en a.
Il est possible de réunir les deux instructions en une seule :
NomDeClasse NomDeVariable = new NomDeClasse() ;
Crée une référence et un emplacement pour un

Point a = new Point() ;
objet de type Point et fournit sa référence en
La situation peut être a.
a ? x
schématisée ainsi : ?
y
EXEMPLE CLASSES ET
OBJETS (5)
On peut appliquer la méthode initialise (…) à l’objet référencié par a.
/*appelle la méthode initialise (…) de la classe Point en l’appliquant à l’objet de référence a, et en
lui transmettant les arguments 3 et 5*/
a.initialise(3, 5) ;
La situation peut a 3 x
5
être schématisée y
ainsi :
Pour employer notre classe Point, nous pouvons définir une

une méthode
méthode mainmain ouméthode
ou une une méthode
d’uned’une
autreautre classe.
classe.
EXEMPLE CLASSES ET
OBJETS (6)
Constructeur de classe : Un constructeur est une méthode particulière
dans une classe. Il porte le même nom que la classe, et permet d’allouer
la mémoire nécessaire à l'objet et d'initialiser ses attributs.
Exemple:
public class Point{
private int x ; //
abscisse private int y ; //
ordonneé public Point (int
abs, int ord)
{ x = abs ;
y=
ord ;
}
public
void
deplace
(int dx,
int dy)
{ x +=
dx ; y
EXEMPLE CLASSES ET
OBJETS (7)
Quelques règles concernant les constructeurs
 Un constructeur ne renvoie aucune valeur. Dans son en-tête,

aucun type ne doit figurer devant son nom. Même la présence
(logique) de void est une erreur.
 Une classe peut ne disposer d’aucun constructeur (c’était le cas de

notre première classe Point). On peut alors instancier des objets
comme s’il existait un constructeur par défaut sans arguments.
 Une classe peut avoir plusieurs constructeurs, qui seront

différenciés par leurs paramètres.
 Un constructeur est toujours appelé à l’aide de l’opérateur new.

EXEMPLE CLASSES ET
OBJETS (8)
Créations inutiles
• La création d'objets est coû teuse. Il faut éviter d'en créer
inutilement :
Objet2 o2 = new Objet2(); L'un des objets ne sera pas
• Objet1 o1 = new Objet1(); utilisé
if(demande == 1)
o1.initialiser();
else
o2.initialiser();
if(demande == 1){
Objet1 o1 = new Objet1();
o1.initialiser();
}
else{
Objet2 o2 = new Objet2();
o2.initialiser();
}
EXEMPLE CLASSES ET
OBJETS (9)
Réutilisation d'objets
• Il faut éviter la création d'objets à l'intérieur d'une boucle.
– Cette création peut être coû teuse en terme de consommation de
la mémoire.
– Préférer la réutilisation d'objet, qui sera instancié avant la boucle,
et modifié à l'intérieur.
for(int i=0 ; i<employes.length ; i++){

Employe emp = new Employe(); //Création d'un objet à chaque passage
emp = (Employe) employes[i];
}
Employe emp = new Employe();

for(int i=0 ; i<employes.length ; i++){
emp = (Employe)
employes[i]; //Réutilisation d'un
seul objet Employe
}
EXEMPLE CLASSES ET
OBJETS (10)
Affectation et comparaison d’objets
Point a, b ; //déclaration de deux objets de type point
a 3 x
a = new Point(3,5);
5
y
b 2 x
b= new Point(2,0) 0
y
Si maintenant nous exécutons l’instruction d’affectation a=b ;
a 3 x
5
b y
2
0 x
y
HÉRITAGE
Caractéristiques de l’héritage
• L'héritage est une propriété importante de la programmation orientée objet

Java.
• Ce concept permettant d'ajouter des nouvelles fonctionnalités à une classe à
partir de la création d’une sous-classe héritant des propriétés de la classe de
base et à laquelle s’ajoutent des nouvelles propriétés.
• La classe héritée s’appelle sous-classe (classe dérivée) de la classe mère
(super-classe).
• L'héritage permettant à une classe dérivée d'étendre les propriétés de la classe
de base tout en héritant des attributs et des méthodes de cette classe de base.
• L’héritage en Java, ne permet à une classe d’hériter que d'une seule classe de
base, on parle d’héritage simple. En effet, pas d’héritage multiple.
HÉRITAGE
• Toutes les classes Java dérivent automatiquement d'une seule et même classe:
la classe Object.
• Donc, l’héritage permet de définir une nouvelle classe à partir d’une classe
existante, à laquelle on ajoute de nouvelles données et méthodes.
HÉRITAGE
- La classe «Materiel » est la classe mère de «MaterielInfo». - La classe «MaterielInfo» est la classe mère de
«Scanner» et «Imprimante».
- La classe «MaterielInfo» est une sous-classe de «Materiel ».
- «Scanner» et «Imprimante» sont des sous-classes de «MaterielInfo» .
HÉRITAGE
Exemple 3: classe «Vehicule»

La modélisation simple de cette classe est représentée comme suit:
Vehicule
marque
couleur
vitesse
etat
demarrer()
arreter()
accelerer()
freiner()
HÉRITAGE
Définition de la classe Vehicule
public class Vehicule {
private String marque;
private String couleur;
private double vitesse; // Vitesse actuelle
private int etat; // 0:arrêt, 1:marche, ...
public Vehicule(String marque, String couleur) {
this.marque = marque;
this.couleur = couleur;
vitesse = 0.0;
etat = 0;
}
public void demarrer() { etat = 1; }
public void arreter() { if (vitesse == 0) etat = 0; }
public void accelerer() {if (etat == 1) vitesse += 5.0;}
public void freiner() {
if (vitesse >= 5.0) vitesse -= 5.0;
else vitesse = 0.0;}
}
HÉRITAGE
Classes dé rivé es de « Vehicule »
 De nouvelles classes « Voiture » et « Camion » peuvent être crées, en utilisant
l'héritage, à partir de « Vehicule ». Elles la spécialisent en y ajoutant de nouvelles
propriétés.
 Un tel diagramme, dans le langage UML, est appelé "Diagramme de classes". Il
montre les relations entre les classes d'une application.
Vehicule
marque
couleur
vitesse
etat
demarrer()
arreter()
accelerer()
freiner()
Camion Voiture
chargeMax modele
poidsChargement nbPortes
charger()
decharger()
HÉRITAGE
Classes dérivées: Camion et Voiture
 La classe Camion est une classe dérivée de Vehicule. Elle hérite tous ses
méthodes et attributs. Elle étend la classe mère Vehicule en lui ajoutant
deux nouveaux attributs chargeMax et poidsChargement, ainsi que deux
nouvelles méthodes charger() et decharger()).
 La classe Voiture est une classe dérivée de Vehicule et hérite tous les
méthodes et les attributs de Vehicule en lui ajoutant deux nouveaux attributs
modele et nbPortes.
 On peut utiliser, dans les classes dérivées Camion et Voiture, les attributs et
les méthodes héritées (par exemple couleur ou freiner()) comme si ces
membres ont été déclarés dans chacune des sous-classes (sous réserve,
naturellement, que les droits d'accès le permettent).
HÉRITAGE
Implémentation de la classe Voiture
• La déclaration d'une classe dérivée se fait en utilisant le mot clé
«extends» suivi du nom de la classe de base.
• Lorsque le mot «extends» est omis, alors la classe hérite
automatiquement de la classe « Object ».
public class Voiture extends Vehicule {

private private String modele; // Nouveau attribut
private int nbPortes; // Nouveau attribut
public Voiture(String marque, String modele, String couleur, int nbPortes)
{ super(marque, couleur); // Appel au constructeur de la classe mère
this.modele = modele;
this.nbPortes = nbPortes;
}
}
HÉRITAGE
Appel des constructeurs : un constructeur d’une classe dérivée peut appeler un
constructeur de sa classe de base. Il suffit de transmettre les paramètres du
constructeur de la sous-classe au constructeur de la super-classe. Ceci est fait par le
mot-clé super.
HÉRITAGE
Accès d’une classe dérivée aux membres de sa classe de base
 Si un champ d'une classe dérivée porte le même nom qu'un champ d'une classe de base,
alors :
 Le champ dérivé masque le champ de base.
 Un code de la classe dérivée peut lire le champ de la classe de base en utilisant le
mot-clé super.
 Le code de la classe de base n’accède pas au champ de sa classe dérivée
Exemple:
public class A {
protected String nom = "Je suis dans A" ;
public void uneMethode() {
System.out.println(nom) ; // affiche "Je suis dans A"
}}
public class B extends A {
protected String nom = "Je suis dans B" ;
public void uneAutreMethode() {
System.out.println(nom) ; // affiche "Je suis dans B"
System.out.println(super.nom) ; // affiche "Je suis dans A"
}}
HÉRITAGE
Accès d’une classe dérivée aux membres de sa classe de base
 Une méthode d’une classe dérivée n’a pas accès aux membres privés de sa classe de
base.
Exemple : on cherche à doter dans la sous-classe PointCol, de la classe Point, la méthode
afficheCouleur qui permet d’afficher les coordonnées du point et la couleur.
Public class Point{ public class PointCol extends Point{
private int x ; // abscisse private int couleur ;
private int y ; // ordonnée
public PointCol( int x, int y, int couleur){
public Point (int x, int y) // constructeur
//par arguments super(x, y); this.couleur=couleur;} Erreur: x et y

Erreur : x et y
{ public void afficheCouleur() {
sontprivées
sont privées
this. x =x ; this.y = y ; }
System.out.println ("Je suis en " + x + " " + y);

public void deplace (int dx, int dy)
{ x += dx ; y += dy ; } System.out.println (" et ma couleur est : " +
public void affiche () couleur) ;
{ System.out.println ("Je suis un point de
}
coordonnees " + this.x + " " + this.y) ;
} public void colore (int c) { couleur = c; }
} }
HÉRITAGE
Redéfinition des méthodes
On appelle redéfinition d’une méthode, la possibilité de définir le comportement d’une
méthode selon le type d’objet l’invoquant, c.-à - d., de donner une nouvelle implémentation à

une méthode héritée sans changer sa signature.
Exemple 1

public void affiche ( )

{
super. affiche() ;
System.out.println (" et ma couleur est : " + couleur) ;
}
HÉRITAGE
 Si une méthode est redéfinie dans une sous-classe, le type de retour doit être identique à
celui de la méthode correspondante de la classe parente.
 En redéfinissant une méthode, il est possible d'étendre sa zone de visibilité (private à package
à protected à public), mais non de la restreindre.
Exemple:
public class A {
private void fonction(float v) { ……}
}
public class B extends A {
public void fonction(float v){…}//redéfinition avec extension des droits d’accès.
}
POLYMORPHISME
• Le polymorphisme est la capacité, pour un même message de correspondre à
plusieurs formes de traitements selon l'objet auquel ce message est adressé, en
se basant sur la relation d’héritage.
• La gestion du polymorphisme est assurée par la machine virtuelle
dynamiquement à l'exécution.
Il est possible d’affecter à une référence d'une classe n'importe quel objet d'une de
ses classe dérivées.
POLYMORPHISME
• Le polymorphisme est la capacité, pour un même message de correspondre à
plusieurs formes de traitements selon l'objet auquel ce message est adressé, en
se basant sur la relation d’héritage.
• La gestion du polymorphisme est assurée par la machine virtuelle
dynamiquement à l'exécution.
Il est possible d’affecter à une référence d'une classe n'importe quel objet d'une de
ses classe dérivées.
POLYMORPHISME
Exemple 1 : Graphique
Cercle Rectangle
public class Graphique {
private int x, y;
public class Cercle extends Graphique
public Graphique ( int x, int y) {
{
this.x = x ; this.y = y ;
private double r ;
}
public Cercle ( int x, int y, double r){
public void identifie () {
super(x,y) ; this.r = r ;
System.out.println ("Je suis une
}
forme géométrique ") ;
public void identifie () {
}
System.out.println ("Je suis un
public void affiche () {
cercle ") ;
this.identifie() ;
}
System.out.println ("Le centre de l’objet
public double surface (){
se trouve dans :"+ x + " et "+ y) ;
return (2* 3.14*r) ;}
}
}
public double surface () {return (0) ;}
}
POLYMORPHISME
Exemple 1 (suite):
public class Rectangle extends Graphique { public class TestPoly {

private int l, L; public static void main (String [] args) {
public Rectangle (int x, int y, int l, int L) Graphique g = new Graphique (3,7);
{ g.identifie ();
super (x,y) ; this.l= l ; this.L =L ; g= new Cercle (4,8,10) ;
} // compatibilité entre le type de la classe
public double surface () { de base et le type de la classe dé rivé e
return (l*L) ;} g.identifie() ;
public void identifie() g= new Rectangle (7,9,10,3) ;
{ // compatibilité entre le type de la classe
System.out.println("Je suis un rectangle") ; de base et le type de la classe dé rivé e
}} g.identifie() ;}}
Je suis une forme géométrique

Résultat d’exécution : Je suis un cercle
Je suis un rectangle
POLYMORPHISME
Test 2 :
public class TestPoly2 { Résultat d’exécution ???
public static void main (String [] args) { Je suis une forme géométrique
Graphique [] tab = new Graphique [6]; Le centre de l'objet se trouve dans : 3 et 2
tab[0] = new Graphique (3,2); Je suis un cercle

tab[1] = new Cercle (10,7,3) ; Le centre de l'objet se trouve dans : 10 et 7
tab [2] = new Rectangle (4,7,8,6) ; Je suis un rectangle
tab [3] = new Graphique (8,10); Le centre de l'objet se trouve dans : 4 et 7
tab[4] = new Cercle (8,5,3) ; Je suis une forme géométrique
tab[5]= new Rectangle (10,17,3,8) ; Le centre de l'objet se trouve dans : 8 et 10
for (int i=0 ; i <=5 ; i++) { Je suis un cercle
tab[i].affiche();} Le centre de l'objet se trouve dans : 8 et 5
} Je suis un rectangle
} Le centre de l'objet se trouve dans : 10 et 17

POLYMORPHISME
Transtypage : conversion de type (cast).
Le transtypage permettant de modifier le type d'une variable ou d'une expression.
Exemple: On peut convertir un int en float.
1)Transtypage des types primitifs
Il existe deux types de transtypages : le transtypage implicite et le transtypage explicite.
 Le transtypage implicite: se fait automatiquement par le compilateur lors d'une
affectation ou du passage d'un paramètre.
 Un transtypage est implicite lorsque le type visé a un plus grand domaine que le
type d'origine.
Exemple: on peut affecter directement un byte à short, ou un int à float (transtypage implicite). Le
compilateur est chargé de cette conversion.
POLYMORPHISME
Transtypage : conversion de type (cast).
 Par contre, si l’on veut convertir une variable ou une expression dans un type qui lui
fait perdre de la précision (domaine plus petit), on doit faire un transtypage explicite.
Exemple: la conversion d’un float en int doit être réalisé par le transtypage explicite.
De même, on doit réaliser un transtypage explicite pour convertir un long en short.
Pour le transtypage explicite : on met entre parenthèses le nom du type dans lequel on veut
convertir, suivi du nom de la variable (ou de l'expression entre parenthèses) à convertir.
Exemple :
float f=10; int i;
i = (int) f; //conversion d'un float en int
POLYMORPHISME
2)Le transtypage de références d'objets
Surclassement (upcasting) et Déclassement (downcasting)

Upcasting : classe fille → classe mère
On appelle le surclassement ou upcasting le fait d’affecter une valeur qui correspond à une
référence d’une instance d’une classe B, héritant d’une classe A, dans une référence de
type A. En java, cette opération est implicite et constitue la base du polymorphisme.
Public class A {…}

Public class B extends A {…}
A a = new B( ) // C ’est de l’upcasting ( le transtypage ascendant).
On dit que a est une référence surclassée (elle est du type A et contient l’adresse d’une
instance d’une sous-classe de A).
POLYMORPHISME
 Un objet d'une classe peut être convertit en un objet d'une autre
classe si les deux classes ont un lien d'héritage.
 La conversion d'un objet dans le sens fille  mère est implicite.
 Par contre, la conversion dans le sens mère  fille doit être explicite
et n'est pas toujours possible.
 Transtypage implicite (fille  mère)
• Il est toujours possible d'utiliser une référence de la classe mère pour
désigner un objet d'une classe dérivée (fille, petite-fille et aussitoutes
les descendances). En effet, Il y a alors un transtypage implicite de
la classe dérivée vers la classe de base.
Ce cas est logique puisqu’un objet dérivé EST un objet de base.
Exemple 1: un employé EST une personne, donc on peut utiliser une
référence de type personne pour désigner un employé. Alors, il y a
un transtypage implicite d'un employé en personne.
POLYMORPHISME
Downcasting : classe mère → classe fille
On appelle déclassement ou downcasting le fait de convertir une
référence « surclassée » pour « libérer » certaines fonctionnalité s cachées
par le surclassement. En java, cette conversion n’est pas implicite, elle doit
ê tre forcé e par l’opérateur de cast : (<nomClasse>).
public class Personne { . . . }
public class Etudiant extends Personne { . . . }
Personne p = new Etudiant( ) ; // surclassement, upcasting
Etudiant e = (Etudiant) p ; // downcasting
Pour que la conversion fonctionne, il faut qu’à l’exécution le type réel de
la référence à convertir soit Etudiant ou une des sous-classes de
Etudiant.
Attention : le downcasting ne permet pas de convertir une instance
d’une classe de base en une instance d’une sous-classe.
public class Personne { Personne( ) {}}
public class Etudiant extends Personne { Etudiant( ) {}}
Personne p = new Personne ( ) ;
Etudiant e = (Etudiant) p ;// Erreur
POLYMORPHISME
Exemple 2 : Materiel
• Il existe une compatibilité ascendante entre les objets:
– Un ordinateur EST un materiel. Ordinateur
– L’inverse est faux : tout materiel n'est pas ordinateur.

• On peut faire une conversion de type (transtypage ou CAST) implicite :
materiel mat = new ordinateur ();
• Le transtypage explicite doit se faire si l'on désire récupérer le type

«ordinateur » à partir du type « Materiel ».
ordinateur ord = (ordinateur) mat;
Note : si le type réel de « mat» n'est pas « ordinateur » ou l’une de ses

classes dérivées, une erreur sera générée.
CLASSE OBJECT
En Java, chaque classe que l'on crée possède une classe parente.
Toutes les classes définies en JAVA sont des sous-classes de la classe de
base « Object ». Ceci est automatique et n’a pas besoin d’être spécifié.
En effet, si on ne définit pas explicitement une classe parente, avec le mot
clé extends, la classe mère par défaut est « Object ». Elle est définie dans
le package java.lang.
 la classe « Object » est la seule classe Java qui ne possède pas de classe
mère.
Il existe plusieurs méthodes dans la classe « Object. Les classes définies
par un programmeur hériteront toutes ces méthodes. Nous en verrons
cinq.
CLASSE OBJECT
Méthode Fonctionnalité
String toString() Retourne une chaîne de caractères représentant l'objet.
boolean equals(Object obj) Indique si l'objet est é gal à un autre.
Retourne la classe d'exécution d'un objet. Par exemple :

Personne m=new Personne();
System.out.println("Classe de Personne : " + m.getClass()) ;

Class getClass()
//affiche Class Personne .
System.out.println(m.getClass().getName()) ;//affiche le nom
de la classe, ici Personne.
Appelée par le « garbage collector » lorsqu’il n'y a plus de

protected void finalize()
ré férences à l'objet.
protected Object clone() Permet de créer et de retourner une copie de l’objet.

LES EXCEPTIONS
types d’erreur dans java
Dans java nous avons 2 types d’erreur qui sont:
• Les compile time error qui sont simplement des erreurs de syntaxe ou
structure de notre code. Et si nous avons ces types d’erreur dans notre code
alors le programme ne démarre tout simplement pas et on reçoit un message
d’erreur,
• Les run time error qui va donc faire planter notre programme apres qu’il soit
compiler et uniquement quand la cause du bug commence.
LES EXCEPTIONS
 Une exception est un objet qui décrit une situation anormal ou
erronée
 Exceptions sont lancé («thrown») par un programme, et peuvent être

attrapé et utilisé par une autre partie du programme
 Un programme peut-être séparé en:
 Un flux normal d’exécution

 Un flux d'exception d’exécution
LES EXCEPTIONS
Prise en charge d'Exception en Java
 Java utilise une ensemble prédéfini d’exceptions et d’erreurs qui peuvent

arriver durant l’exécution
 Un programme peut s’occuper d’une exception d’une de 3 façons:
 L’ignorer
 S’en occuper là ou elle arrive
 S’en occuper dans une autre place dans le programme
LES EXCEPTIONS
Prise en charge d'Exception :La commande «try»
Afin de s’occuper d'une exception quand elle arrive, l'on met la ligne qui lance
l'exception dans un block try
Un block try est suivie de un ou plus de clause catch qui s'occupent de l'exception
Chaque clause catch à un type d’exception associé
Quand une exception prend place, la 1ère clause catch dont le type d'exception
correspond s'en occupe
LES EXCEPTIONS
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.
LES EXCEPTIONS
Interceptions de plusieurs exceptions
Dans un gestionnaire try...catch, il est en fait possible d'intercepter plusieurs types d'exceptions
différentes et de les traiter.
Dès qu'une exception intervient dans le < bloc de code à protéger>, la Java machine traite
séquentiellement toutes les clauses catch de la première jusqu'à la nième. Si l'exception actuellement
levée est d'un des types présents dans la liste des clauses le traitement associé est effectué, l’examination
est abandonnée et le programme poursuit son exécution après le gestionnaire.
try {
< bloc de code à protéger>
}
catch ( TypeException1 E ) { <Traitement TypeException1 > }
.....
catch ( TypeExceptionk E ) { <Traitement TypeExceptionk > }
Où
• TypeException1, TypeException12, ... , TypeExceptionk sont des classes d'exceptions obligatoirement toutes
distinctes.
• Seule une seule clause catch ( TypeException E ) {...} est exécutée (celle qui correspond au bon type de l'objet
d'exception instancié).
LES EXCEPTIONS
Exemple théorique, supposons que la méthode meth() de la classe Action2 puisse lever trois types différents
d'exceptions: ArithmeticException, ArrayStoreException, ClassCastException.
Notre gestionnaire d'exceptions est programmé pour intercepter l'une de ces 3 catégories.
LES EXCEPTIONS
Ordre d'interception d'exceptions hiérarchisées
Dans un gestionnaire try...catch comprenant plusieurs clauses, la recherche de la clause catch contenant le traitement
de la classe d'exception appropriée, s’effectue séquentiellement dans l’ordre d’écriture des lignes de code.
Soit le pseudo-code java suivant :

try {
< bloc de code à protéger générant un objet exception>
}
.....
catch ( TypeExceptionk E ) { <Traitement TypeExceptionk > }
La recherche va s'effectuer comme si le programme contenait des if...else if... imbriqués. Les tests seraient effectués
sur l'appartenance de l'objet d'exception à une classe à l'aide de l'opérateur instanceof.
On choisira donc, lorsqu’il y a une hiérarchie entre les exceptions à intercepter, de placer le code de leurs clauses
dans l’ordre inverse de la hiérarchie.
LES EXCEPTIONS
Déclenchement d'une exception : throw
Il est possible de déclencher soi-même des exceptions en utilisant l'instruction throw, voir même de déclencher des
exceptions personnalisées.
Déclenchement manuel d'une exception existante
La Java machine peut déclencher une exception automatiquement comme dans l'exemple de la levée d'une
ArithmeticException lors de l'exécution de l'instruction "x = 1/0 ;".
La Java machine peut aussi lever (déclencher) une exception à votre demande suite à la rencontre d'une instruction
throw. Le programme qui suit lance une ArithmeticException avec le message "Mauvais calcul !" dans la méthode
meth() et intercepte cette exception dans le bloc englobant main. Le traitement de cette exception consiste à afficher le
contenu du champ message de l'exception grâce à la méthode getMessage() :
LES EXCEPTIONS
Déclenchement d'une exception : throw
LES EXCEPTIONS
Déclenchement manuel d'une exception personnalisée
Pour une exception personnalisée, le mode d'action est strictement identique, il vous faut seulement auparavant
créer une nouvelle classe héritant obligatoirement de la classe Exception ou de n'importe laquelle de ses sous-
classes.
LES EXCEPTIONS
Exception non vérifiée
La majorité des exceptions de Java font partie du package java.lang. Certaines exceptions sont tellement
courantes qu'elles ont été rangées dans une catégorie dénommée la catégorie des exceptions implicites ou non
vérifiées (unchecked), les autres sont dénommées exception explicites ou vérifiées (checked).
Une exception non vérifiée (implicite) est une classe dérivant de l'une des deux classes Error ou
RuntimeException :
java.lang.Object
|
+--java.lang.Throwable
|
+--java.lang.Error
|
+--java.lang.Exception
|
+--java.lang.RuntimeException
LES EXCEPTIONS
Méthode propageant une exception vérifiée : throws
Une méthode dans laquelle est levée une ou plusieurs exceptions vérifiées doit obligatoirement signaler au
compilateur quelles sont les classes d'exceptions qu'elle laisse se propager sans traitement par un gestionnaire
(propagation vers un bloc englobant).
Java dispose d'un spécificateur pour ce signalement : le mot clef throws suivi de la liste des noms des classes
d'exceptions qui sont propagées.
LES EXCEPTIONS
Une méthode dans laquelle est levée une ou plusieurs exceptions vérifiées doit obligatoirement signaler au
compilateur quelles sont les classes d'exceptions qu'elle laisse se propager sans traitement par un gestionnaire
(propagation vers un bloc englobant).
Java dispose d'un spécificateur pour ce signalement : le mot clef throws suivi de la liste des noms des classes
d'exceptions qui sont propagées.
Résultats de l'exécution :
---- java UseAction4
UseAction4.java:8: unreported exception java.io.IOException;
must be caught or declared to be thrown
throw new IOException("Problème d'E/S !");
^
1 error
LES EXCEPTIONS
Le compilateur Java attendait de notre part l'une des deux seules attitudes suivantes :
Soit nous interceptons et traitons l'exception IOException à l'intérieur du corps de la méthode où elle a été
lancée avec pour conséquence que le bloc englobant n'aura pas à traiter une telle exception puisque l'objet
d'exception est automatiquement détruit dès qu'il a été traité.
LES EXCEPTIONS
Soit nous interceptons et traitons l'exception IOException à l'intérieur du bloc englobant la méthode meth()
qui a lancé l'exception, auquel cas il est obligatoire de signaler au compilateur que cette méthode meth()
lance et propage une IOException non traitée. Le code ci-après implante la seconde attitude possible :
LES EXCEPTIONS
Clause finally
Supposons que nous soyons en présence d'un code contenant une éventuelle levée d'exception, mais
supposons que quoiqu'il se passe nous désirions qu'un certain type d'action ait toujours lieu (comme par
exemple fermer un fichier qui a été ouvert auparavant). Il existe en Java une clause spécifique optionnelle
dans la syntaxe des gestionnaires d'exception permettant ce type de réaction du programme, c'est la clause
finally. Voici en pseudo Java une syntaxe de cette clause :
<Ouverture du fichier>
try {
< action sur fichier>
}
finally {
<fermeture du fichier>
}
.... suite
LES CLASSES
 Concept des classes abstraites ABSTRAITES
 Une classe abstraite est une classe qui ne permet pas l’instanciation des objets de son type. C’est une classe
incomplète puisqu’elle contient certaines méthodes dont leurs corps sont définies dans la classe dérivée.
En effet, elle doit être héritée.
 Une classe abstraite comporte une ou plusieurs méthodes abstraites, et elle peut comporter d'autres
méthodes non abstraites.
 Une méthode abstraite est une méthode qui ne possède pas d’instructions (corps). Elle comporte seulement
une signature de définition suivie du caractère point-virgule.
Une méthode abstraite doit être précédée par le mot clé abstract. Exemple :
public abstract double f();
LES CLASSES
 Syntaxe
ABSTRAITES (2)
abstract class Personne {
public void affiche() {……} // affiche() est définie dans Personne
public abstract void determineAge (int n) ; //determineAge() est
//une méthode abstraite, elle n’est pas définie dans Personne.
}
 Utilisation
Personne p ; //on peut déclarer une référence sur un objet de type

//Personne ou dérivé.
p = new Personne (….); //Erreur, pas d’instanciation d’objets

//d’une classe abstraite.
LES CLASSES
ABSTRAITES (3)
Une classe abstraite peut être utile pour imposer l'existence de certaines méthodes dans des classes, sans savoir
comment elles seront implémentées.
abstract class Graphique {

….
abstract void affiche();
}
class Rectangle extends Graphique{ class Cercle extends Graphique{

…. ….
public void affiche (){ public void affiche ()
Syso ("Je suis un rectangle") ;} { Syso ("Je suis un cercle")
} ;}
}
Une classe qui hérite d'une classe abstraite doit redéfinir les méthodes abstraites, sinon elle est abstraite également.
En C++, les méthodes abstraites sont dites virtuelles pures.
LES CLASSES
 Règles des classes abstraites
ABSTRAITES (4)
 Une classe est automatiquement abstraite si une de ses méthodes est abstraite.
 On doit déclarer également une classe abstraite par le mot clé abstract.
 Une méthode abstraite ne peut pas être privée, ce qui est logique puisque son corps sera définit
dans une classe dérivée.
 Les noms d’arguments muets doivent figurer dans la définition d’une méthode abstraite.
public abstract void determineAge (int); //Erreur : nom argument
fictif est obligatoire
 Une classe dérivée d’une classe abstraite n’est pas obligée de redéfinir toutes les méthodes
abstraites, elle peut ne redéfinir aucune, mais elle reste abstraite tant qu’il y a encore des
méthodes abstraites non implémentées.
 Une classe dérivée d’une classe non abstraite peut être déclarée abstraite.
LES CLASSES
ABSTRAITES (5)
 Règles des classes abstraites (2)
 Une classe abstraite est non instanciable (donc il n’est pas possible d’utiliser les constructeurs de
cette classe et donc on ne peut pas créer des objet de son type.)
 Une classe dérivée d'une classe abstraite ne devient concrète que si elle implémente toutes les
méthodes abstraites de sa classe de base.
 Une méthode abstraite ne possède pas de corps, mais doit être implémentée dans les classes
dérivées non abstraites : abstract fonction (arguments); ce n'est qu'une signature .
 Une classe abstraite peut contenir des méthodes non abstraites et des déclarations de variables
ordinaires.
LES CLASSES
ABSTRAITES (6)
 Intérêt des classes abstraites
 Les classes abstraites facilitent largement la conception orientée objet.
 On peut placer dans une classe abstraite toutes les fonctionnalités dont on souhaite disposer pour
les classes descendantes :
 Soit sous la forme d’une implémentation complète de méthodes (non abstraites) et de champs
lorsqu’ils sont communs à tous les descendants,
 Soit sous forme d’interface des méthodes abstraites dont on est alors sûr qu’elles existeront dans
toute classe dérivée instanciable.
LES CLASSES
 Exemple :
ABSTRAITES (7)
 Considérons la hiérarchie des classes suivantes
:
Surface () Graphique
Cercl Rectangle
e
On veut que les classes Cercle et Rectangle disposent de la méthode surface() retournant la
surface de la figure géométrique définie par la classe.
LES CLASSES
ABSTRAITES (8)
public abstract class Graphique
{ private int x, y;
//Une classe abstraite ne peut
pas être instanciée, mais elle
peut avoir un
//constructeur :
public graphique ( int x, int y) {
this.x = x ; this.y = y ;}
//Voilà la méthode abstraite à

compléter :
public abstract double
surface();
//Toutes les méthodes ne sont

pas abstraites :
public void affiche() {
System.out.println ("Le centre de l’objet se trouve dans :" + x+ " et " +
LES CLASSES
ABSTRAITES (9)
public class Cercle extends Graphique
{ private double rayon =1 ;
public Cercle ( int x, int y, double
r){ super(x,y) ; rayon = r ;}
public double surface ()
{ return (2* 3.14
*rayon) ; }
}
public class Rectangle extends Graphique

{ private int larg, lng ;
public Rectangle ( int x, int y, int larg, int lon)
{ super (x,y) ; this.lng = lon ; this.larg =
larg ;}
public double surface ()
{ return (lng*larg);}
LES CLASSES
ABSTRAITES (10)
public class TestPoly2 {
public static void main (String [] args) {
Graphique [] tab = new Graphique [6];
//tab[0] = new Graphique (3,2);//Erreur, classe abstraite est non
instanciable
//Même si la classe Graphique est abstraite, il est tout de même
possible
//de déclarer des variables de ce type qui pourront recevoir des objets
//créés à partir des sous-classes concrètes :
tab[0] = new Cercle (3,2,7);
tab[1] = new Cercle (10,7,3) ;
tab[2] = new Rectangle (4,7,8,6)
;
tab[3] = new Rectangle
(8,10,12,10); tab[4] = new Cercle
(8,5,3) ;
LES
 Concept d’interface
INTERFACES
Une interface est un ensemble d'opérations utilisées pour spécifier un service offert par une classe.
 Elle peut être vue comme une classe sans attributs (sauf les constantes) et dont toutes les opérations
sont spécifiées mais pas définies à priori.
 Elle peut être vue comme un contrat ou un modèle que doivent offrir toutes les classes qui se
réclament (implémentent) de cette interface.
public interface Polygon{

public int surface();
public void deplace(int a, int b);
}
LES
INTERFACE
S (2)
Le corps d'une interface ressemble beaucoup à celui d'une classe abstraite avec cependant les
différences suivantes :
Une interface ne peut définir que des méthodes abstraites. Le modificateur abstract n'est pas
nécessaire (java 7).
Toutes les méthodes abstraites sont implicitement publiques même si le modificateur public est omis.
 Une interface ne peut pas définir de champs d'instance.
Une interface peut cependant contenir des constantes déclarées static et final (tous les champs sont
implicitement static et final même si les modificateurs correspondants sont omis).
Une interface ne définit pas de constructeur (on ne peut pas l'instancier et elle n'intervient pas dans le
chaînage des constructeurs).
LES
INTERFACES
(3)
 Si l’on considère une classe abstraite n’implémentant aucune méthode et aucun champ (sauf les
constantes), on aboutit à la notion d’interface.
 Une interface définit les entêtes d’un certain nombre de méthodes, ainsi que des constantes.
 L’interface est plus riche qu’un simple cas particulier des classes abstraites :
 Une classe peut implémenter plusieurs interfaces (alors qu’une classe ne pouvait dériver que d’une
seule classe abstraite).
 Les interfaces peuvent se dériver.
 Une classe dérivée peut implémenter 1 ou plusieurs interfaces, elle peut même réimplémenter une
interface déjà implémentée par la superclasse.
 On pourra utiliser des variables de type interface.
LES
INTERFACES
 Syntaxe
public interface Interface1{ (4)
void f (int n); //public abstract est facultatif
void g (); //public abstract est facultatif
}
 Implémentation d’une interface

Lorsqu’on définit une classe, on peut préciser qu’elle implémente une interface donnée
en utilisant le mot clé « implements ».
public interface Interface1

{….}
public interface Interface2
{…}
public class A implements Interface1, Interface2
{…..A doit définir les méthodes de Interface 1 et Interface 2}
LES
INTERFACES
Exemple
1:
public interface (5) public class Flottant implements Affichable
Affichable{ void affiche() ;
{ private float val ;
}
public Flottant (float n){
public class Entier implements Affichable
val = n ;
{ private int val ;
}
public Entier (int n) {
val = n ;}
System.out.println ("Je suis un flottant de
valeur " + val) ;
System.out.println ("Je suis un entier de
}
valeur" + val) ;
}
}
}
public class TestInterface {
public static void main (String [] args)
{ Affichable [] tab = new Affichable [2]; Résultat de l’exécution
tab[0] = new Entier (25);
- Je suis un entier de valeur 25
tab [1] = new Flottant (1.25); tab
[0].affiche(); - Je suis un flottant de valeur 1.25
tab [1].affiche (); }
}
LES
Exemple 2 :
INTERFACES
(6)
public interface Perimetre { public float per(); }
public interface Surface { public float sur(); }
public interface Resultat { public void result(); }
Rectangle
implémente
public class Rectangle implements Perimetre, Surface, Resultat{les interfaces Perimetre
private float A, Surface et Resultat
B;
public Rectangle (float a, float b) { A= a; B= b; }
public float per()
{public
return(2*(A+B));
float sur() }
{ return(A*B); } public void
result() {
System.out.println("Per
imetre= "+ per());
System.out.println("Sur
face = "+ sur()); }
}
public class Test1Interface {

public static void main (String [] args)
LES
INTERFACES
(7)
 Interface et constantes
 Une interface peut renfermer aussi des constantes symboliques qui seront accessibles à toutes
les classes implémentant l’interface :
public interface I{
static final int max = 100 ;
void f (int n);
void g () ;
}
 Les constantes déclarées sont toujours considérées comme « static » et « final »

LES
INTERFACE
 Interface et dérivations
 L’interface
S (8)
est totalement indépendante de l’héritage :Une classe dérivée peut
implémenter une ou plusieurs interfaces.
 L'implémentation d'une ou plusieurs interfaces (implements) peut être combinée

avec l'héritage simple (extends).
 La clause implements doit suivre la clause extends.
interface I1 {…..}
interface I2 {…..}
class A implements I1 {……}
class B extends A implements I1, I2 {…..}

LES
INTERFACES
Exemple 2 :
(9)
public interface Perimetre { public float
per(); } public interface Surface { public float
sur(); } public interface Resultat { public void
result(); }
public class Rectangle implements Perimetre, Rectangle implémente
Surface{ public float A, B; les interfaces Perimetre
public Rectangle (float a, float b) { A= a; B= b; } et Surface
public float per() { return(2*(A+B)); }
public float sur() { return(A*B); }
}
Square hérite
public class Square extends Rectangle implements
de
Resultat{ public Square (float a) { super(a, a); } Rectangle
public void result() {
System.out.println("Perimetre= "+ per());
System.out.println("Surface = "+ sur()); }
}
public class Test2Interface {
public static void main (String []
args){ Square S= new
Square(5.0f); S.result(); }}
LES
INTERFACES
(10)
Quelques propriétés d’interfaces :
 Lorsqu'une classe déclare une interface dans sa clause implements,

elle indique ainsi qu'elle s'engage à fournir une implémentation
(c'est- à-dire un corps ) pour chacune des méthodes de cette
interface.
 Si une classe implémente une interface mais ne fournit pas

d'implémentation pour toutes les méthodes de l'interface, c-à-d elle
hérite des méthodes (abstraites) non implémentées , elle doit être
déclarée abstract.
 Si une classe implémente plus d'une interface, elle doit implémenter

toutes les méthodes de chacune des interfaces mentionnées dans la
clause implements (ou alors doit être déclarée abstract).
LES
Exemple :
INTERFACES
(11)
public interface Affichage{ public void affiche(); }
public abstract class Figure implements
Affichage{
public abstract double perimetre(); // Méthode
abstraite public abstract double surface(); // Méthode
abstraite
}
//Pourquoi cette classe est
abstraite??. public class Cercle
extends Figure {
public static final double PI =
3.14;
protected double rayon;
public Cercle(double rayon) { this.rayon= rayon;
} public double getRayon() { return rayon; }
public double perimetre() { return 2*PI*rayon; }
public double surface() { return PI*rayon*rayon;
LES
 Conflits des noms INTERFACES (12)
 Soit l’exemple
suivant :
interface I1 { Supposons que la méthode « g () » est
void f(int présentée de 2 façons différentes dans I1 et
I2
n) ; void interface I1 {
g(); void g();
}
interface I2 { } // g est une méthode abstraite de
I1
void f (float x); interface I2 {
void g(); int g();
} } // g est aussi une méthode abstraite de
I2
class A implements I1, I2
class A implements I1,
I2{ {/* Erreur car void g() et int g() ne peuvent
pas coexister au sein de la même classe*/
/*A doit implémenter la
}
méthode g existante dans les
2 interfaces une seule fois*/
}
ACCÈS AUX
BASES DE
DONNÉES AVEC
L'APIJDB
C
INTRODUCTION
• Dans de nombreuses applications, il est nécessaire de se connecter à une
base de données.
• Liste non exhaustive de SGBD :
ACCESS : plate-forme Windows, mono-poste, licence commerciale
SQL SERVER : Windows, mode client/serveur, commerciale.
ORACLE : Windows et Linux, mode client/serveur, commerciale.
SYBASE : Windows et Linux, mode client/serveur, commerciale.
POSTGRESQL : Windows et Linux, mode client/serveur, licence libre
MYSQL : Windows et Linux, mode client/serveur, licence libre. C'est le

SGBD le plus répandu (On va utiliser ce SGBD).
• Pour se connecter à une base de données et effectuer des manipulations sur
cette base, on va utiliser les packages java.sql et javax.sql.
INTRODUCTION (2)
 JDBC : Java Data Base Connectivity
 Framework permettant l'accès aux bases de données relationnelles dans
un programme Java.
Indépendamment du type de la base utilisée (mySQL, Oracle,...)
 Seule la phase de connexion au SGBDR qui se change.
 Permet de faire tout type de requêtes : sélection, création de tables,
insertion d'éléments dans les tables et la gestion des transactions.
 JDBC interagit avec le SGBDR par un driver.
 Types de drivers
JDBC-ODBC bridge plus ODBC driver: ce driver est présent dans
J2SE (sun.jdbc.odbc.JdbcOdbcDriver). Il permet l’accès au SGBD via le
driver ODBC.
Native-API partly-Java driver: ce driver traduit les appels de JDBC à
un SGBD particulier, grâce à un mélange d'API Java et d'API natives.
JDBC-Net pure Java driver: ce type de driver (écrit entièrement en
Java) passe par un serveur intermédiaire pour l'accès au SGBD.
Native-protocol pure Java driver (que l’on va utiliser): Ce type de
driver (écrit entièrement en Java) se connecte directement au SGBD.
ETAPES PRINCIPALES POUR L’ACCÈS À UNE BDD
 Première étape
Préciser le type de driver que l'on veut utiliser.
Driver permet de gérer l'accès à un type particulier de SGBD.
 Deuxième étape
Récupérer un objet « Connection » en s'identifiant auprès du SGBD
et en précisant la base utilisée.
 Etapes suivantes
A partir de la connexion, créer un « Statement
» (état) correspondant à une requête particulière.
 Exécuter ce statement au niveau du SGBD
Fermer le statement.
 Dernière étape.
Se déconnecter de la base en fermant la connexion.
ETAPES PRINCIPALES POUR L’ACCÈS À UNE BDD (2)
CHARGEMENT DU PILOTE (DRIVER) DE MYSQL
CHARGEMENT DU PILOTE (DRIVER) D‘ORACLE
CLASSES ET INTERFACES PRINCIPALES DE JDBC
 Objet de type DriverManager : charge et configure le driver de la

base de données.
 Objet de type Connection : réalise la connexion et l’authentification à
la base de données.
 Objet de type Statement (et PreparedStatement) : contient la
requête SQL et la transmet à la base de données.
 Objet de type ResultSet : permet de parcourir les informations
retournées par la base de données dans le cas d’une sélection de
données.
 Il contient les données de la ligne courante et un pointeur sur la
ligne suivante.
CLASSE: DRIVERMANAGER
Méthodes principales
 static void registerDriver(Driver driver) :

 Enregistre le driver (objet driver) pour un
typede SGBD particulier.
 Le driver est dépendant du SGBD utilisé.
 static Connection getConnection(String url, String user, String
password):
 Crée une connexion permettant d'utiliser une base de
données.
 url : identification de la base considérée sur le SGBD, le format de
l'URL est dépendant du SGGB utilisé.
 user : nom de l'utilisateur qui se connecte à la base de données.
password : mot de passe de l'utilisateur.
URL de connection
 Afin de localiser la base de donnée sur le serveur de base de
données, il est indispensable de spécifier une adresse de connexion
sous la forme d'une URL. Ces URL commenceront toutes par
"jdbc:".
 Généralement, il faudra se référer à la documentation du fournisseur
du driver afin de connaître le format de l'URL à utiliser.
 Pour MySQL, l'URL est la suivante :
jdbc:mysql://host:port/database.
 Host : correspond à l'adresse IP du serveur.

 port : port MySQL ou port par défaut.
 database : le nom de la base de donnée à laquelle on doit se connecter.
Établir une connection

 Établir une connexion en utilisant la classe java.sql.DriverManager.
Son rôle est de créer des connexions en utilisant le driver
préalablement chargé.
 Cette classe dispose d'une méthode statique getConnection() prenant
en paramètre l'URL de connexion, le nom d'utilisateur et le mot de
passe.
INTERFACE: CONNECTION
 Préparation de l'exécution d'instructions sur la base, 2 types:

 Instruction simple : objet de type Statement
On exécute directement et une fois l'action sur la base.
Instruction paramétrée : objet de type PreparedStatement
L'instruction est générique, des champs sont non remplis.
Permet une pré-compilation de l'instruction optimisant
les performances.
Pour chaque exécution, on précise les champs manquants.
Pour ces 2 instructions, 2 types d'ordres possibles.
Update : mise à jour du contenu de la base de données.
Query : consulation (avec un select) des données de la base.
INTERFACE: CONNECTION (2)
 Statement createStatement()
Retourne un état permettant de réaliser une instruction simple.
 PreparedStatement prepareStatement(String ordre)
Retourne un état permettant de réaliser une instruction paramétrée
et pré-compilée pour un ordre.
Dans l'ordre, les champs libres (au nombre quelconque)
sont précisés par des « ? ».
 Ex : ''select nom from clients where ville=?'‘
Lors de l'exécution de l'ordre, on précisera la valeur du champ.
 void close(): ferme la connexion avec le SGBD.
INTERFACE: STATEMENT
 ResultSet executeQuery(String ordre)

Exécute un ordre de type SELECT sur la base.
Retourne un objet de type ResultSet contenant tous les résultats
de la requête.
 int executeUpdate(String ordre)

Exécute un ordre de type INSERT, UPDATE, ou DELETE.
 void close() : ferme l'état.

INTERFACE: STATEMENT
Statement statement = connection.createStatement( );

int count = statement.executeUpdate( "UPDATE City
SET population=130000 WHERE name=‘Beni Mellal'" );
System.out.println("Modified " + count + " records");
Scanner console = new Scanner(System.in);

System.out.print( "Name of city to find? " );
String name = console.nextLine().trim();
String query = "SELECT * FROM city WHERE Name='" +name+ "'";
ResultSet rs = statement.executeQuery( query );
INTERFACE: PREPAREDSTATEMENT
 Avant d'exécuter l'ordre, on remplit les champs avec:

void set[Type](int index, [Type] val): remplit le champ en ième
position définie par index avec la valeur « val » de type « Type ».
 « Type » peut être : String, int, float, long ...
 ResultSet executeQuery()
Exécute un ordre de type SELECT sur la base.
Retourne un objet de type ResultSet contenant tous les résultats
de la requête.
 int executeUpdate(): exécute les requêtes INSERT, UPDATE, ou
DELETE.
INTERFACE: PREPAREDSTATEMENT (EXEMPLE)
PreparedStatement pstmt = connection.prepareStatement(

"SELECT * FROM Country where name = ?" );
// get data for Maroc

pstmt.setString( 1, “Maroc");
ResultSet rs = pstmt.executeQuery( );
INTERFACE: RESULTSET
 Contient les résultats d'une requête SELECT.
Plusieurs lignes contenant plusieurs colonnes.
On y accède ligne par ligne, puis valeur par
valeur dans la ligne.
 Changements de ligne
boolean next(): se place à la ligne suivante
s'il y en a une et retourne
true si le déplacement a été fait, false s'il n'y
avait pas d'autre ligne.
boolean previous(): se place à la ligne précédente s'il y en a une et
retourne true si le déplacement a été fait, false s'il n'y avait pas de ligne
précédente.
boolean absolute(int index) : se place à la ligne numérotée par index et
retourne true si le déplacement a été fait, false sinon.
 Accès aux colonnes/données dans une ligne
[type] get[Type](int col) : retourne le contenu de la colonne col dont
l'élément est de type [type] avec [type] pouvant être String, int, float,
boolean ...
INTERFACE: RESULTSET
String query = "SELECT * FROM Country WHERE ...";

ResultSet rs = statement.executeQuery( query );
// go to first row of results

get by column number
rs.first( );
// display the values get by name
System.out.println( rs.getString( 1 ) );
System.out.println( rs.getInt( "population" ) );
getInt( ), getLong( ) - get Integer field value
getFloat( ), getDouble() - get floating pt. value
getString( ) - get Char or Varchar field value
getDate( ) - get Date or Timestamp field value
getBoolean( ) - get a Bit field value
getBytes( ) - get Binary data
getBigDecimal( ) - get Decimal field as BigDecimal
getBlob( ) - get Binary Large Object
getObject( ) - get any field value
Fermeture du ResultSet : void close()

EXEMPLE
public class SqlBase {
public static void main (String []args){
Connection con; Statement transm ; ResultSet res;
try{
//Chargemement du driver
Class.forName("com.mysql.jdbc.Driver");
//Configuaration du driver, insertion des info. de connexion ici
con=DriverManager.getConnection("jdbc:mysql://localhost/maBase","root","");
//transm contient nos requêtes et les transmet à la BD
transm=con.createStatement(); - maBase est une base de données
crée par MySQL.
//Exécution de la requête - produit est une table de la BD
res=transm.executeQuery("select * from produit"); contient les attributs: Id,
Désignation, PU et Quantité
while(res.next()){
System.out.println("Id: "+res.getInt("Id")+"\t Désignation:"
+res.getString("Désignation")+"\t PU: "+res.getDouble("PU")+"\t
Quantité: "+res.getInt("quantité"));
}
}catch(Exception e){
System.out.println("Erreur");}
}}
Développement Web J2EE :
Servlet, JSP, MVC,
Architecture J2EE
Serveur d’application : TOMCAT
Couche WEB
Couche
Client Métier DAO
Couche
• HTML 1 Contrôleur
Servlet 2
• CSS
3
• Java Script
HTTP
4 Modèle DAO
Métier
5 Java Données
6 Beans
Vue
JDBC
JSP
SGBD
LE PROTOCOLE HTTP
 HTTP :HyperText Tranfert Protocol
 Protocole qui permet au client de récupérer des documents du
serveur
 Ces documents peuvent être statiques (contenu qui ne change
pas : HTML, PDF, Image, etc..) ou dynamiques ( Contenu généré
dynamiquement au moment de la requête : PHP, JSP, ASP…)
 Ce protocole permet également de soumissionner les formulaires
 Fonctionnement (HTTP/1.0)
 Le client se connecte au serveur (Créer une socket)
 Le client demande au serveur un document : Requête HTTP
 Le serveur renvoi au client le document (status=200) ou d’une
erreur (status=404 quand le document n’existe pas)
 Déconnexion
Méthodes du protocole HTTP
 Une requête HTTP peut être envoyée enutilisant
les méthodes suivantes:
 GET : Pour récupérer le contenu d’un document
 POST : Pour soumissionner des formulaires (Envoyer,
dans la requête, des données saisies par l’utilisateur )
 PUT pour envoyer un fichier du client vers le serveur
 DELETE permet de demander au serveur de
supprimer un document.
 HEAD permet de récupérer les informations sur un
document (Type, Capacité, Date de dernière
modification etc…)
Le client envoie la requête : Méthode POST
Entête de la requête
Post /page HTTP/1.0 Méthode,chemin,version
host: www.exemple.com Nom de domaine

Code de la langue
HTTP_ACCEPT_LANGUAGE : fr
Type et version du
User-Agent : Mozilla/5.0 navigateur
*** saut de ligne ***
login=Valeur1 Paramètres des différents

champs du formulaire.
password=Valeur2
corps de la requête
Le client envoie la requête : Méthode GET
Entête de la requête
GET /page?login=valeur1&password=valeur2 HTTP/1.0

host: www.exemple.com
HTTP_ACCEPT_LANGUAGE : fr
User-Agent : Mozilla/4.0
corps de la requête est vide

Le Serveur retourne la réponse :
Entête de la réponse
HTTP/1.0 200 OK Ligne de Status

Date : Date du serveur
Server : Nom du
Last-Modified : Serveur
Content-Type : Text/html Dernière modification
Content-legnth : taille Type de contenu
*** saut de ligne *** Sa taille
<HTML><HEAD>
…. Le fichier que le client
</BODY></HTML> va afficher
@youssfi.ne
tcorps de la réponse
Introduction aux
servlets
Navigateur web Serveur web
Requête HTTP
Conteneur de servlet
Method=GET ou POST
request
Servlet
Réponse HTTP doGet()
response doPost()
(HTML, javascript, css…)

session
Introduction aux
servlets
 Composant logiciel écrit en Java fonctionnant du coté serveur
 Au même titre que PHP, ASP (Active Server Pages)
 Permet de gérer des requêtes HTTP et de fournir au client une
réponse HTTP
 Une Servlet s’exécute dans un moteur de Servlet ou conteneur
de Servlet permettant d’établir le lien entre la Servlet et le serveur
Web
L’API Servlet
 Étendre cette classe

pour construire des
Servlets "génériques"
 Étendre cette classe pour

construire des Servlets
propre au protocole
HTTP
HttpServlet
 Dans la suite du cours nous allons utiliser uniquement des
Servlets qui réagissent au protocole HTTP d'où l'utilisation de la
classe HttpServlet
 HttpServlet redéfinit la méthode service(…)
 service(…) lit la méthode (GET, POST, …) à partir de la requête
 Elle transmet la requête à une méthode appropriée de
HttpServlet destinée à traiter le type de requête (GET, POST, …)
Fonctionnement d’une servlet
 Lorsqu'une servlet est appelée par un client, la méthode
service() est exécutée. Celle-ci est le principal point
d'entrée de toute servlet et accepte deux objets en
paramètres:
 L'objet HttpServletRequest encapsulant la requête du client,
c'est-à-dire qu'il contient l'ensemble des paramètres passés à la
servlet (informations sur l'environnement du client, cookies du
client, URL demandée, ...)
 L'objet HttpServletResponse permettant de renvoyer une réponse
au client (envoyer des informations au navigateur).
Développement d’une
servlet
 Une servlet est une classe qui hérite de la classe
HttpServlet et qui redéfinit les méthodes du
protocole HTTP.
 Si la méthode utilisée est GET, il suffit de redéfinir la
méthode :
 public void doGet(
HttpServletRequest request,
HttpServletResponse response
)
 Si la méthode utilisée est
POST, il suffit de redéfinir
la méthode :
 public void doPost(
HttpServletRequest request,
HttpServletResponse response
)
Première Servlet
package web;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class MaServlet extends HttpServlet{
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws
ServletException, IOException {
resp.setContentType("text/html");
PrintWriter pr=resp.getWriter();
pr.println("<html><head><title>Titre de la page</title></head><body>corps de la
page</body></html>");
pr.close();
}} med@youssfi.ne
t
Structure d’un projet Web J2EE
 Le dossier src contient les
classes java
 Le byte code est placé
dans le dossier
build/classes
 Les dossier webapp
contient les documents
Web comme les pages
HTML, JSP, Images, Java
Script, CSS …
 Le dossier WEB-INF
contient les descripteurs
de déploiement comme
web.xml
 Le dossier lib permet de
stocker les bibliothèques
de classes java
(Fichiers.jar)
Déploiement d’une
servlet
 Pour que le serveur Tomcat reconnaisse une servlet, celle-ci
doit être déclarée dans le fichier web.xml qui se trouve dans
le dossier WEB-INF.
 Le fichier web.xml s’appelle le descripteur de déploiement de
Servlet.
 Ce descripteur doit déclarer principalement les éléments
suivant :
 Le nom attribué à cette servlet
 La classe de la servlet
 Le nom URL à utiliser pour faire appel à cette servlet via le
protocole HTTP.
web.xml
<?xml version="1.0" encoding="UTF-8"?><web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-
app_3_1.xsd"
version="3.1">
Balise de description de
<display-name>CoursServlet</display- l'application WEB
name>
<servlet> Nom de la Servlet
<servlet-name>MaServlet</servlet-name> "Identification"
Classe de la Servlet
<servlet-class>web.MaServlet</servlet-class>
</servlet>
Définition d'un chemin
<servlet-mapping> virtuel
<servlet-name>MaServlet</servlet-name>
<url-pattern>/est</url-pattern> Nom de la Servlet considér
</servlet-mapping> "Identification"
</web-app> URL assocée à la servlet

Servlet
3.0
 Pour un projet web J2EE, utilisant un module web, version
3.0, le fichier web.xml n’est pas nécessaire.
 Dans ce cas, le déploiement d’une servlet peut se faire
en utilisant des annotations:
package web;
import j a v a . i o . * ; import j a v a x . s e r v l e t . * ;
import j a v a x . s e r v l e t . a n n o t a t i o n . * ;
import j a v a x . s e r v l e t . h t t p . * ;
@WebServlet(name="cs",urlPatterns={"/fs","*.do"})
public class F i r s t S e r v l e t extends HttpS erv let {
}
Tester la servlet
Code source coté client

HttpServletRequest
 HttpServletRequest hérite de ServletRequest
 Cet objet encapsule la requête HTTP et fournit des méthodes
pour accéder
 aux informations du client
 à l'environnement du serveur
 Exemples de méthodes
 String getMethod() : retourne le type de requête
 String getServerName() : retourne le nom du serveur
 String getParameter(String name) : retourne la valeur d'un
paramètre
 String[] getParameterNames() : retourne le nom des les
paramètres
 String getRemoteHost() : retourne l'IP du client
 String getServerPort() : retourne le port sur lequel le serveur
écoute
 String getQueryString() : retourne la chaîne d’interrogation
 … (voir l'API Servlets pour le reste)
HttpServletRequest
 Exemple : Quelques méthodes de l’objet request
package web;
import j a v a . i o . * ; import javax.servlet.*;import j a v a x . s e r v l e t . h t t p . * ;
public class FirstServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
} PrintWriter
out=response.getWriter();
response.setContentType("text/html");
out.println("<html><body><ul>");
out.println("<li>Protoc ol: " + request.getProtocol()+"</li>");
out.println("<li>ServerName: " + request.getServerName()+"</li>");
out.println("<li>ServerPort: " + request.getServerPort()+"</li>");
out.println("<li>RemoteAddr: " + request.getRemoteAddr()+"</li>");
out.println("<li>RemoteHost: " + request.getRemoteHost()+"</li>");
out.println("<li>Method: " + request.getMethod()+"</li>");
out.println("<li>Paramètre URL nom: " + request.getParameter("nom")+"</li>");
out.println("</ul></body></html>");
}
Une page JSP Equivalente :
Exemple1.jsp
<%@page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "
http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html;
charset=ISO-8859-1">
< t i t l e > I n s e r t t i t l e h e re </ ti tle >
</head>
<body>
<ul >
<li
>P
rot
oc
ol:
<%
ou
t .p
ri n
t ln
( r
eq
ue med@youssfi.ne
st. t
ge
tPr
Forwarding
 Pour séparer les rôles une servlet peut faire
un forward vers une JSP de la manière
suivante :
package web;
public class FirstServle t extends HttpServlet {
@Override
request.getRequestDispatcher("Exemple1.jsp").forward(reque
st, response);
}
}
Tomcat
Requête
HTTP FW
Client
Contrôleur Vue
Servlet
HTTP Réponse JSP
HTTP
Première comparaison entre Servlet et
JSP
 Une servlet est une classe java dans laquelle on peut générer du code
HTML alors qu’une JSP est une sorte de page HTML,à l’intérieur de
laquelle, o peut écrire du code Java.
 Les pages JSP sont très pratique quand on veut afficher les vues
de l’applications alors que les servlets sont pratique pour effectuer
les traitement nécessaires au fonctionnement d’une application.
 Si une servlet nécessite d’être déployée (web.xml), une JSP est
déployée automatiquement par Tomcat.
 Pendant le premier appel d’une JSP, Tomcat convertit la JSP en servlet
et la déploie automatiquement.
 Quand un client HTTP demande une page JSP, c’est la servlet
correspondante à cette JSP, qui est générée par Tomcat qui est
excécutée.
 Tout ce qu’on peut faire avec une servlet, peut être fait par une JSP.
(Unse JSP est une servlet)
 La technologie de base des applications web J2EE c’est les
servlets.
 Dans une application web J2EE qui respecte le pattern MVC,
 Les servlets sont utilisées pour jouer le rôle du contrôleur
 Les JSP sont utilisées pour jouer le rôle des vues
HttpServletResponse
 HttpServletResponse hérite de ServletResponse
 Cet objet est utilisé pour construire un message de
réponse HTTP renvoyé au client,
 il contient les méthodes nécessaires pour définir le type
de contenu, en-tête et code de retour

un flot de sortie pour envoyer des données
(par exemple HTML) au client
 Exemples de méthodes :
 void setStatus(int) : définit le code de retour de la
réponse
 void setContentType(String) : définit le type de
contenu MIME
 PrintWriter getWriter() : Retourne un objet PrintWriter permettant
d'envoyer du texte au navigateur client. Il se charge de convertir
au format approprié les caractères Unicode utilisés par Java
 ServletOutputStream getOutputStream() : flot pour envoyer des
données binaires au client
 void sendRedirect(String) : redirige le navigateur vers l'URL
HttpServletResponse :

Redirection
Une servlet peut rediriger vers une autre ressourse locale ou distante
en utilisant la méthode sendRedirect() de l’objet response.
package web;
public class FirstServle t extends HttpServlet {
@Override
response.sendRedirect("Vue.jsp"); }
}
Requête
HTTP
Tomcat
Client Contrôleur : Servlet
HTTP Vue : JSP

Réponse
HTTP
Exemple : effectue un pull
client
package web;
private i n t compteur;
@Override
public void i n i t ( ) throws ServletException
{ compteur=9;
}
@Override
response.setContentType("text/plain");
PrintWriter out = response.getWriter();
i f (compteur > 0 ) Toutes les 1 seconde
{ r esponse. set Header ( "Ref r esh", " la page est rechargée
1") ; et cela 9 fois de suite
--compteur;
out.println(compteur + " . . . " ) ;
} else
{ out . pr i nt l n( "Fi
n") ;
}}}
Cycle de vie d’une
Le serveur crée un pool de threads auxquels il va pouvoir
servlet

affecter chaque requête
 La servlet est chargée au démarrage du serveur ou lors de la
première requête
 La servlet est instanciée par le serveur
 La méthode init() est invoquée par le conteneur
 Lors de la première requête, le conteneur crée les objets
Request et Response spécifiques à la requête
 La méthode service() est appelée à chaque requête dans un
nouveau thread. Les objets Request et Response lui sont
passés en paramètre
 Grâce à l'objet request, la méthode service() va pouvoir
analyser les informations en provenance du client
 Grâce à l'objet response, la méthode service() va fournir une
réponse au client
 La méthode destroy() est appelée lors du déchargement de la
servlet, c'est-à-dire lorsqu'elle n'est plus requise par le serveur.
La servlet est alors signalée au garbage collector .
Cycle de vie d’ne
servlet
 A chaque rechargement d’une Servlet par le
conteneur de Servlet, il y a création d’une
nouvelle instance et donc destruction de
l’ancienne

Le rechargement d’une Servlet a lieu
quand il y a :
 Modification d’au moins une classe
de l’application WEB
 Demande explicite de l’administrateur du
serveur WEB
 Redémarrage du conteneur de Servlets
Paramétrer une servlet
 Une servlet peut être paramétrée dans le fichier web.xml.
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
version="3.1">
<servlet>
<servlet-name>cs</servlet-name>
<servlet-class>web.FirstServlet</servlet-class>
<init-param>
<param-name>var1</param-name>
<param-value>Hello</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>cs</servlet-name>
<url-pattern>/home</url-pattern>
</servlet-mapping>
</web-app>
med@youssfi.ne
t
Lire les paramètre dans une
servlet
 La méthode init() d’une servlet est l’endroit
idéale pour lire les paramètres de

configuration d’une servlet.
 Dans la Servet précédente, pour lire le
paramètre var1,on peut réécrire la servlet
de la manière suivante:
Paramétrer une servlet
package web;
private S t r i n g message;
@Override
public void i n i t ( ) throws ServletException
{ String
param1=getInitParameter(« var1");
}
protected void doGet(HttpServletRequest request,
HttpServletResponse response) throws
ServletException, IOException {
response.setContentType("text/html");
PrintWriter out=response.getWriter();
out.print(message);
}
}
Application Mapping Objet Relationnel
orientée objet public List<User> getAllUsers() throws ClassNotFoundException,
Users:Collection SQLException{
List<User> users=new ArrayList<User>();
:User Class.forName("com.mysql.jdbc.Driver");
idUser=2
Connection conn=DriverManager.getConnection
("jdbc:mysql://localhost:3306/test","root","");
login=user1 PreparedStatement ps=conn.prepareStatement ("select *
password=123456 from users");
email=…..
ResultSet rs=ps.executeQuery();
while(rs.next()){
ville=…… User u=new User();
u.setIdUser(rs.getInt("id"));
:User
u.setLogin(rs.getString("login"));
idUser=3 u.setPassword(rs.getString("password"));
login=user3 u.setEmail(rs.getString("email"));
u.setVille(rs.getString("ville"));
password=testpass
users.add(u);
email=….. }return(users);}
ville=……
Table users
:User
……
……
…..
Application
 Le travail à faire consiste à afficher les clients en
saisissant un mot clé qui représente la ville de
l’utilisateur
 La vue qu’on souhaite réaliser est la suivante :
Serveur TOMCAT : 8089
Architectur CoursJee : Web App
e Couche Web Couche Métier
ControleurServlet User
4
2
doPost(req,resp)3 5
1
UserModele UserImpl
ville: String
HTTP users:List<user>
getClientsParV(v):List
8 6 7
SingletonConnection
usersView.jsp
1 Le client envoie la requête au contrôleur web.xml JDBC

2 Le contrôleur instancie le modèle
3 Le contrôleur Stocke les données de la requête dans le modèle puis vérifie la validité des données
4 Le contrôleur Fait appel à la couche métier pour faire les traitement
5 Le contrôleur Stocke les résultats de traitement dans le modèle
SGBC MYSQL : 3306
6 Le contrôleur fait un forward vers la vue JSP
7 La vue récupère les résultats du modèle
8 Le contrôleur affiche au client le résultat de la vue
Base de données
Structure de la table users :
Données de la table users :

Couche
web
 La couche web est définie par :
 Le modèle qui permet de stocker les données qu’on va
saisir (ville) et le résultat à afficher (List<User>). Le
reste étant les Getters et Setters
 Le contrôleur qui est une servlet qui va se charger de:
 Créer un objet du modèle
 Stocker les données de la requête (ville) dans ce modèle
 Récupérer les résultats de la couche métier
 Stocker ces résultats dans le modèle
 Faire appel à la vue JSP.
 La vue (usersView.jsp) qui va se charger de récupérer le
modèle et d’afficher les résultats.
Couche Métier
 La couche métier se compose de :
 La classe User
 Un singleton Connection qui contient une
méthode getConnection qui retourne un
objet Connection unique vers la base de
données, quelque soit le nombre de
machines clientes connecté au serveur
 Une classe UserImpl qui contient une méthode
qui permet de retourner une Liste des
utilisateurs sachant un mot clé (ville).
 Une application pour tester UserImpl
Classe User.java
package metier;
public class User {
int id;
String login;
String password;
String email;
String ville;
public User() {
super();
}
public User(int id, String login, String password, String
email, String ville) {
super();
this.id = id;
this.login = login;
this.password = password;
this.email = email;
this.ville = ville;
}
// Getters et Setters
}
Classe SingletonConnection
package metier;
import java.sql.Connection;
import java.sql.DriverManager;
public class SingletonConnection {

private static Connection connection;
static{
try { Class.forName("com.mysql.jdbc.Driver");
connection=DriverManager.getConnection
("jdbc:mysql://localhost:3306/test","root","");
} catch (Exception e) {
e.printStackTrace();
}
}
public static Connection getConnection() {
return connection;
}
}
La classe UserImpl.java
package metier;
import java.sql.*;
import java.util.*;
public class UserImpl {
public List<User> getClientsParV(String v){
List<User> allusers=new ArrayList<User>();
Connection conn=SingletonConnection.getConnection();
try {
PreparedStatement ps=conn.prepareStatement ("select * from users where ville
like ?");
ps.setString(1, "%"+v+"%");
ResultSet rs=ps.executeQuery();
while(rs.next()){
User u=new User();
u.setId(rs.getInt("id"));
u.setLogin(rs.getString("login"));
u.setEmail(rs.getString("EMAIL"));
u.setVille(rs.getString("VILLE"));
allusers.add(u);
}
} catch (SQLException e) { e.printStackTrace();
}
return allusers;
}}
Classe Test
package metier;
import java.util.List;
public class Test {
UserImpl users=new UserImpl();
List<User> liste_users=users.getClientsParV(« fkih");
for(User u:liste_users)
System.out.println(u.getLogin());
}
}
Le modèle : UserModele.java
package web;
import java.util.*;
import metier.User;
public class UserModele {
private String ville;
private List<User> users=new ArrayList<User>();
// Geters et Setters
}
Le contrôleur :
package web;
ControleurServlet
import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
import metier.*;
public class ControleurServlet extends HttpServlet {
private UserImpl users;
@Override
public void init() throws ServletException {
users=new UserImpl();
}
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse
response)
UserModele moduser=new UserModele();
moduser.setVille(request.getParameter("ville"));
List<User> liste_users=users.getClientsParV(moduser.getVille());
moduser.setUsers(liste_users);
request.setAttribute("modele", moduser);
request.getRequestDispatcher("usersView.jsp").forward(request,
response);
}
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
doPost(req, resp);
}}
Descripteur de déploiement de servlets :
web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
version="3.1">
<servlet>
<servlet-name>fbs</servlet-name>
<servlet-class>web.ControleurServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>fbs</servlet-name>
<url-pattern>/users</url-pattern>
</servlet-mapping>
</web-app>
La vue : usersView.jsp
<%@page import="metier.User"%><%@page import="java.util.List"%>
<%@page import="web.UserModele"%>
<%
UserModele mod;
if(request.getAttribute("modele")!=null){
mod=(UserModele)request.getAttribute("modele");
}
else{ mod=new UserModele(); }
%>
<html>
<body>
<form action="users" method="post">
Ville:<input type="text" name="ville" value="<%=mod.getVille() %>">
<input type="submit" value="Chercher">
</form>
<table border="1" width="80%">
<tr>
<th>ID</th><th>LOGIN</th><th>EMAIL</th><th>VILLE</th>
</tr>
<%
List<User> users=mod.getUsers();
for(User u:users){%>
<tr>
<td><%=u.getId() %></td> <td><%=u.getLogin() %></td>
<td><%=u.getEmail() %></td> <td><%=u.getVille() %></td>
</tr>
<% } %>
</table></body></html>

Java EE Partie 1

Transféré par

Droits d'auteur :

Formats disponibles

Java EE Partie 1

Transféré par

Informations du document

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 EE Partie 1

Transféré par

Droits d'auteur :

Formats disponibles

OBJECTIFS DU COURS

 Décrire les éléments-clé de la plate-forme Java

 Compiler et exécuter une application Java

 Comprendre et utiliser la documentation en ligne de Java

 Décrire la syntaxe du langage

 Comprendre le paradigme OO et utiliser Java pour le mettre en œuvre

 Comprendre et utiliser les exceptions

 Comprendre la gestion des événements

 Développement des applets

Plateforme = environnement hardware ou software sur

Le compilateur Java génère un bytecode, c’est à dire un

Chaque programme est compilé et interprété

Quelques versions de la Machine Virtuelle

Deux façons d’écrire des programmes Java:

En utilisant un environnement de développement (IDE)

APPLICATION VERSUS APPLET

Une applet Java

• Les instructions Java se terminent par un ;

Pour pouvoir faire un programme exécutable, il faut toujours une

– C’est le point d’entrée dans le programme : le

public static void main(String args[ ])

Créer un fichier texte : Bonjour.java

public class Bonjour La première ligne du programme doit être la

· Compiler le programme : javac Bonjour.java

• On a besoin de nommer les classes, les variables, les constantes, etc. ;

Java dispose de trois formes de commentaires :

 Tout texte entre « /* » et « */ »

abstract default goto null synchronized

boolean do if package this

break double implements private throw

byte else import protected throws

case extends instanceof public transient

catch false int return true

char final interface short try

class finally long static void

continue float native super volatile

const for new switch while

Java est un langage fortement typé

Deux types de données:

In teg ral F lo ating

b yte 8 bits -12 8 to 1 27 flo at 3 2b its 1 .4 E-4 5 3 .4E 38

ch ar 16 b its 0 to 6 55 35 o n e b it : tru e o r fa lse

Déclaration, Initialisation et Assignation des types primitifs

int t; Déclaration d’un entier t (t est l’identificateur)

Déclaration et initialisation de 2 entiers: a et b

Désormais, il existe deux variables en mémoire qui ont la

Tous les types hormis les types primitifs

La portée d'une variable va de la ligne de sa définition jusqu'à la fin du bloc dans

Quelle est la valeur de : 5+3*4+(12/4+1)

Niveau Symbole Signification

Pour comparer deux valeurs:

Opérateur Usage Renvoie TRUE si

L’opérateur de base est ‘=‘

Opérateur Exemple Équivalent à

+= expr1 += expr2 expr1 = expr1 + expr2

-= expr1 -= expr2 expr1 = expr1 – expr2

*= expr1 *= expr2 expr1 = expr1 * expr2

/= expr1 /= expr2 expr1 = expr1 / expr2

%= expr1 %= expr2 expr1 = expr1 % expr2

• Les structures de contrô le classiques existent en Java :

= expr1 = expr2 expr1 = expr1 * expr2