ENSEM

COURS DE

Java - JEE

Enseignant : Pr. AOUN Oussama

Année Universitaire 2024/2025

 Java - JEE
Déroulement du cours

Séances de théorie
Séances de TP sur ordinateur
Évaluation pratique sur ordinateur
Examen sur le contenu du cours
Projet par groupes de 2 ou 3.

2
Software Requirement

[Java Environment]
Java (SE) 6 or higher http://www.java.com/
[Web application container]
Apache Tomcat 5.x or higher
http://tomcat.apache.org/
[Database]
Microsoft Access 2003 or higher
[Integrated Development Environment]
Eclipse
http://www.eclipse.org/downloads/
 Introduction & Rappel

ENSEM Java - JEE 3

 Caractéristiques Principales de
Java
Le langage Java est :
▪ « C-like » : Syntaxe familière aux programmeurs de C
▪Orienté objet : Tout est objet, sauf les types primitifs
(entiers, flottants, booléens, ...)
▪ Robuste : Typage fort, pas de pointeurs, etc.
▪Code intermédiaire : Le compilateur ne produit que du
bytecode indépendant de l’architecture de la machine où a
été compilé le code source

“Write Once, Run Anywhere : écrire une fois, exécuter

partout”

ENSEM Java - JEE 5

 Quelques chiffres
- 97% des machines d'entreprises ont une JVM installée
- Java est téléchargé plus d'un milliards de fois chaque année
- Il y a plus de 9 millions de développeurs Java dans le monde
- Java est un des langages les plus utilisé dans le monde
- Plus de 3 milliards d'appareils mobiles peuvent utiliser Java
-Plus de 1,4 milliards de cartes à puce utilisant Java sont
produites chaque année

ENSEM Java - JEE 6

Langage compilé

Etapes qui ont lieu avant l'exécution pour un langage compilé

comme C++

Fichier
de Librairies
code

Programme
Compilation Code objet Edition de liens
exécutable

Autres code objet

Fichier
d'entête

7
Langage interprété

Cas de Java
Avant exécution Exécution

Autres byte code

Fichier
Byte code Machine virtuelle
de code Compilation
Java (JVM)
Java
javac MaClasse.class java
MaClasse.java

8
L’API de Java

Java fournit de nombreuses librairies de classes

remplissant des fonctionnalités très diverses : c'est
l'API Java
API (Application and Programming Interface /Interface
pour la programmation d'applications) : Ensemble de
bibliothèques permettant une programmation plus aisée
car les fonctions deviennent indépendantes du matériel.
Ces classes sont regroupées, par catégories, en
paquetages (ou "packages").

9
L’API de Java (2)

Les principaux paquetages

java.util : structures de données classiques
java.io : entrées / sorties
java.lang : chaînes de caractères, interaction avec l'OS, threads
java.applet : les applets sur le web
java.awt : interfaces graphiques, images et dessins
javax.swing : package récent proposant des composants « légers » pour la
création d’interfaces graphiques
java.net : sockets, URL
java.rmi : Remote Method Invocation (pas abordé dans ce cours)
java.sql : fournit le package JDBC (pas abordé dans ce cours)

10
L’API de Java (3)

La documentation de Java est standard, que ce

soit pour les classes de l'API ou pour les classes
utilisateur
possibilité de génération automatique avec l’outil
Javadoc.
Elle est au format HTML.
intérêt de l'hypertexte pour naviguer dans la
documentation

11
L’API de Java (4)

Pour chaque classe, il y a une page HTML contenant :

la hiérarchie d'héritage de la classe,
une description de la classe et son but général,
la liste des attributs de la classe (locaux et hérités),
la liste des constructeurs de la classe (locaux et hérités),
la liste des méthodes de la classe (locaux et hérités),
puis, chacune de ces trois dernières listes, avec la
description détaillée de chaque élément.

12
 L’API de Java (5)

Où trouver les informations sur les classes de l’API

sous le répertoire jdk1.x/docs/api dans le JDK
les documentations de l’API se téléchargent et s’installent
(en général) dans le répertoire dans lequel on installe java.
Par exemple si vous avez installer Java dans le répertoire
D:/Apps/jdk1.4/, vous décompresser le fichier zip
contenant les documentations dans ce répertoire.
Les docs de l’API se trouveront alors sous :
D:/Apps/jdk1.4/docs/api/index.html
Sur le site de Sun, on peut la retrouver à
http://java.sun.com/docs/index.html

13
L’API de Java (6)

14
 The Java 2 Platform

Platform introduced June, 1999

- J2SE – Java 2 Standard Edition
Java for the desktop / workstation
http://java.sun.com/j2se
- J2ME – Java 2 Micro Edition
Java for the consumer device
http://java.sun.com/j2me
- JEE - Java 2 Enterprise Edition –Jakarta EE
Java for the server
http://java.sun.com/j2ee
 Evolution de Java

Personal Java 1.0 / 1.1 / 1.2 FDT, I/O, Collection et Outils,

Applet + Thread, AWT + Swing,
TCP/ IP + UDP / IP, RMI, New I/O,
Java2 SDK SE 1.3.0, Expression rationnelle, Image I/O,
Java2D, Java3D, JAI, JMF, Son, JCE,
1.3.1, 1.4.0 JSSE, JAAS

JSP + Servlet + JavaBeans, EJB,

RMI-IIOP and CORBA, JNDI,
JDK1.0 JDK 1.1 Java2 SDK EE Java2 SDK
OAK 1.2.1 EE 1.3.0
JMS, JDBC, XML

(91-94)

Plateforme Java Java2 SDK ME (Micro Pour téléphones cellulaires

PDA, JINI, JIRO **
Edition)

Plateforme Java2
Java embarqué
•Java 1.0.2
•Java 1.1.1 , 1.1.2, 1.1.3, 1.1.8
•Java 1.2.2
ENSEM Java - JEE 1
 Les différents types d’applis

Applications autonomes

Exécutable Données
 Les différents types d’applis

Applications déportées

Terminal ou Gestionnaire
d'écrans Données
émulateur
 Les différents types d’applis

Applications client/serveur

Exécutable Données
 Les différents types d’applis

Applications client/serveur distribuées ou 3-tiers

Exécutable Exécutable Données

 Les différents types d’applis

Les applications client léger ou applications web

Navigateur Serveur
HTML/Javascript d'applications Données
 Evolution du Web : Applications web

Développement des pages dynamiques :

- générées à partir d'une base de données : pas besoin d'écrire des centaines de pages
HTML
(ex : site de presse)
- apportent un contenu personnalisé à l'utilisateur (ex : messagerie)
- ne nécessitent pas d'installation sur le poste de l'utilisateur
(ex : annuaire de l'école)

HTML
Technologies du web dynamique

3 solutions :
ASP (.Net) :
Active Server Page
fonctionne uniquement avec un serveur MS Windows
PHP :
PHP Hypertext Processor
gratuit : communauté libre
fonctionne avec tout type de serveur
simple à apprendre
limité (mais nouvelles versions…)

ASP
PHP
 Technologies du web dynamique

3 solutions :
Java : Servlets/JSP :
gratuit , mais sous la houlette de Jakarta
fonctionne avec tout type de serveur
programmation objet structurée, modulaire et évolutive
richesse des interfaces
répandu dans les entreprises
peu d’hébergements disponibles

servlet
JSP

25
 Les applications Web en Java

Serveur web capable d'exécuter du Java :

serveur d'application JEE JEE
web container JEE
Un serveur JEE est capable d'exécuter :
des servlets : classes Java exécutées côté serveur
des JSP :
Java Server Pages
Fichiers de script qui « mélangent » du Java et du HTML/Javascript

26
 Web dynamique : principes

2 : le serveur accepte la
1 : le navigateur rassemble connexion reçoit la
les informations du requête, retrouve les
formulaire, il se connecte au informations transmises
serveur et lui transmet ces et recherche les données
informations dans une correspondantes
requête HTTP

4 : le navigateur
affiche la page et 3 : le serveur génère
rompt la connexion dynamiquement une page
avec le résultat, l'envoie
en réponse HTTP au
navigateur
 Rappel sur JAVA

ENSEM Java - JEE 2

 Comment obtenir JAVA

http://www.oracle.com/technetwork/java/javase/downloads/index.html

Documentation:
http://docs.oracle.com/javase/11/docs/api/index.html

ENSEM Java - JEE 2

 Java Development Kit de Sun
Le compilateur javac
La syntaxe est la suivante : javac [options] [fichiers] [@fichiers]

L'interpréteur java/javaw
Ces deux outils sont les interpréteurs de byte code : ils lancent le JRE, chargent les classes nécessaires et
executent la méthode main de la classe.
java ouvre une console pour recevoir les messages de l'application alors que javaw n'en ouvre pas.

L'outil JAR/WAR
JAR est le diminutif de Java ARchive. C'est un format de fichier qui permet de regrouper des fichiers
contenant du byte-code Java (fichier .class) ou des données utilisées en temps que ressources (images,
son, ...). Ce format est compatible avec le format ZIP : les fichiers contenus dans un jar sont compressés
de façon indépendante du système d'exploitation.

Pour générer la documentation : l'outil javadoc

Cet outil permet de générer une documentation à partir des données insérées dans le code source.

ENSEM Java - JEE 8

 Exécution du code JAVA

Erreurs…
public class Toto {
1001 1101
Pas d’erreurs… 1110 1101
public static void main (String[] 0011 0110
args){ Compilateur
int i; 0000 0001
for (i = 0 ; i<10 ; i++) JAVA …
System.out.println("Hello World");
} Byte code
}

Code source Toto.class

Toto.java

Hello World
Hello World
Hello World
…
Machine
virtuelle
ENSEM Introduction(JàVJMEE) 6 9
 Environnements de
développement
Editeur de texte + lignes de commande
Les éditeurs simples : Jcreator, Emacs, JEdit
Les éditeurs avancés
o Eclipse http://www.eclipse.org/
o NetBeans http://www.netbeans.org/
o IntelliJ IDEA
o RAD
o JDeveloper
o JBuilder
o BlueJ

ENSEM Java - JEE 32

 La méthode main
⚫ La méthode main est une méthode de classe publique, qui
contient le « programme principal » à exécuter et qui a pour
signature :
public static void main(String[] args)

⚫ Attention
⚫ La méthode main ne peut pas retourner d’entier comme en C.

public static int main(String[] args)

ENSEM Java - JEE 33

 La méthode main

ENSEM Java - JEE 12

 Concepts POO

Héritage (Polymorphisme, Interface, Class abstraite,

relation <<instance de>>, casting)
Visibilité et encapsulation
Attributs et Méthodes statiques

ENSEM Java - JEE 13

 Héritage

⚫ L’héritage est une relation entre deux Object

classes.
⚫ Ex. Etudiant hérite de Personne:
• La classe étudiant et un sous-type (sous-
classe) de la classe Personne
(superclasse). Personne
⚫ Syntaxe: mot clé "extends"
• public class Etudiant extends Personne {
…}
⚫ En Java, une classe ne peut pas hériter
de plus d'une classe.
⚫ Si l'héritage n'est pas déclaré, la classe Enseignant
hérite implicitement de Etudiant
java.lang.Object
◼ une hiérarchie de classes

ENSEM Java - JEE 36

 Sémantique d'héritage:
attributs et méthodes
⚫ La sous classe (ex. Etudiant) possède des attributs et des
méthodes définis dans la superclasse (ex. Personne).
⚫ Ex.
public class Etudiant extends Personne {
public class Personne { String noEtudiant;
String nom; public Etudiant(String _nom, _noEtudiant) {
nom = _nom;
public void envoyerMail( noEtudiant = _noEtudiant;
String adr, String message) envoyerMail("[email protected].
{ ….} ma", "creation de dossier : " +
nom);
} }
}

ENSEM Java - JEE 37

La classe Objet

● Classe mère de toutes les classes.

Possède des méthodes de base qu'il est
●

possible de redéfinir :
–toString()

–equals() & hashCode()

–getClass()

–clone()

–finalize()

ENSEM Java - JEE 38

 Tests d’égalité

●Les opérateurs de comparaison == et != tests les

valeurs des variables :
–Pour les types primitifs, on test leurs valeurs
–Pour les types objets, on test les valeurs de leurs références
Point p1;
p1=new Point(2,2);
Point p2;
p2=p1
Point p3; Variables locales x 2 y2
p3=new Point(2,2);
p1==p2; // true p1
p1==p3; // false p2
p2==p3; // false p3 x 2 y2

ENSEM Java - JEE 39

La méthode equals()

Il existe déja une méthode equals(Object) dans

●

Object
● Mais son implémentation test les références
Point p1=new Point(2,2);
Point p3=new Point(2,2);

p1==p3; // false
p1.equals(p3); // false

●Pour comparer structurellement deux objet, il

faut changer (on dit redéfinir) le code de la
méthode equals()
ENSEM Java - JEE 40
 constructeur
⚫ Chaque classe a un ou plusieurs constructeurs
• qui servent à créer les instances
• initialiser l'état de ces instances
⚫ Un constructeur :
• a le même nom que la classe
• n'a pas de type de retour
• peut disposer d’un nombre quelconque d’arguments
(éventuellement aucun).
ENSEM Java - JEE 41
 Constructeur : exemple

ENSEM Java - JEE 42

Plusieurs constructeur : surcharge

ENSEM Java - JEE 43

 Constructeur privé
⚫ Exemple 1:
class ClasseA{
private ClasseA() { … } // constructeur privée sans arguments
…}
ClasseA a = new ClasseA(); // erreur, car ClasseA() est privé
⚫ Exemple 2:

public class CacheSingleton {

private static CacheSingleton instance = new CacheSingleton();
private Map<Long, Object> cache = new HashMap<Long, Object>();
private CacheSingleton() { }
public static synchronized CacheSingleton getInstance() {return
instance; }
…
ENSEM Java - JEE 44
 Les constructeurs en héritage
⚫ La première instruction d'un constructeur peut être un appel :
• à un constructeur de la classe mère : super(...)
• ou à un autre constructeur de la classe : this(...)
⚫ Interdit de placer this() ou super() ailleurs qu'en première
instruction d'un constructeur

⚫ Il n'est pas possible d'utiliser à la fois un autre constructeur

de la classe et un constructeur de sa classe mère dans la
définition d'un de ses constructeurs.

ENSEM Java - JEE 45

 Constructeur de la classe mère

ENSEM Java - JEE 46

 Constructeurs de la classe fille

ENSEM Java - JEE 47

 Appel implicite du constructeur
de la classe mère
⚫ Si la première instruction d'un constructeur n'est ni
super(...), ni this(...), le compilateur ajoute au début un
appel implicite au constructeur sans paramètre de la classe
mère (super() ) .

⚫ Un constructeur de la classe mère est toujours exécuté

avant les autres instructions du constructeur.
⚫ La première instruction d'un constructeur de la classe mère
est l'appel à un constructeur de la classe « grand-mère », et
ainsi de suite...

⚫ La première instruction exécutée par un constructeur est le

constructeur (sans paramètre) de la classe Object !
ENSEM Java - JEE 48
 Constructeur implicite :
exemple 1

ENSEM Java - JEE 49

 Constructeurs : exemple 2

ENSEM Java - JEE 50

 Constructeurs : exemple 2

ENSEM Java - JEE 51

 Constructeurs : exemple 2

ENSEM Java - JEE 52

 Constructeur implicite : erreur

ENSEM Java - JEE 53

 Constructeur implicite :
correction

ENSEM Java - JEE 54

Redéfinir equals()

Pourquoi equals ?
●

Car elle sert à cela.

La plupart des classes de l’API redéfinissent la
●

méthode equals
public class Point {
private final int x,y;
public Point(int x,int y) {
this.x=x;
this.y=y;
}
public boolean equals(Point p) {
return x==p.x && y==p.y;
}
} // est ce que c’est bon ?

ENSEM Java - JEE 55

Redéfinir equals()

Point p1=new Point(2,2);

Point p3=new Point(2,2);
p1==p3; // false
p1.equals(p3); // true

ArrayList points=new ArrayList();

points.add(p1);
points.contains(p3); // false
// pourtant contains utilise Object.equals(Object) ??

La VM ne fait pas la liaison entre

●

Object.equals(Object) et Point.equals(Point)

ENSEM Java - JEE 56

Redéfinir equals()

Ce n'est pas le même equals(), car il n'y a pas

●

eut de redéfinition mais une autre définition (on

dit surcharge)
Point p1=new Point(2,2);
Point p3=new Point(2,2);
p1.equals(p3); // true : Point.equals(Point)

Object o1=p1;
Object o3=p3;
o1.equals(o3); // false : Object.equals(Object)

●Point possède deux méthodes equals

(equals(Object) et equals(Point))

ENSEM Java - JEE 57

Redéfinir equals()

Il faut définir equals() dans Point de telle façon

●

qu'elle remplace equals de Object

Pour cela equals doit avoir la meme signature
●

que equals(Object) de Object

public class Point {
private final int x,y;
public Point(int x,int y) {
this.x=x;
this.y=y;
}
public boolean equals(Object p) {
return x==p.x && y==p.y; // ce code ne marche pas
}
}

ENSEM Java - JEE 58

Utiliser @Override

●@Override est une annotation qui demande au

compilateur de vérifier que l'on redéfinie bien
une méthode
public class Point {
private final int x,y;
public Point(int x,int y) {
this.x=x;
this.y=y;
}
@Override public boolean equals(Point p) {
...
} // the method equals(Point p) in Point must override
// a superclass method
}

ENSEM Java - JEE 59

Redéfinir equals

●On demande dynamiquement à voir une

référence à Object comme à Point
(car on le sait que c'est un Point)
public class Point {
...
@Override public boolean equals(Object o) {
Point p=(Point)o; // ClassCastException si pas un Point
return x==p.x && y==p.y;
}
}

Mais equals doit renvoyer false si o n'est pas

●

un Point et pas lever une ClassCastException

ENSEM Java - JEE 60

Redéfinir equals

●On utilise instanceof qui renvoie vrai si une

référence est d'un type particulier
public class Point {
...
@Override public boolean equals(Object o) {
if (!(o instanceof Point)) // marche aussi avec null
return false;
Point p=(Point)o;
return x==p.x && y==p.y;
}
}

● null instanceof WhatYouWant renvoie false

ENSEM Java - JEE 61

 Exemple: redéfinition de la méthode
equals(…)

Object
equals(…) {
public Personne { // comparer par
String noSecu; identité
… }
public boolean equals(Object autre)
{
if(autre instanceof Personne) {
Personne p2 = (Personne) autre; Personne
if(noSecu.equals(p2.noSecu)) String
equals(…) { equals(…) {
return true; // comparer par // comparer
} contenu (no de sécurité par contenu
sociale) }
return false; }
}
}

ENSEM Java - JEE 62

 Accès aux méthodes redéfinies dans la
superclasse

⚫ Même si la sous classe redéfinit des méthodes de la superclasse,

elle a le moyen d'accéder à ces méthodes en utilisant le mot clé
<<super>>. public class B extends A{
public class A { public B(String s) {
public A(String s) { super(s);
System.out.println("A : " + s); System.out.println("B : " + s);
} }
public void m1() { public void m1() {
System.out.println("A.m1"); super.m1();
} m2(); // pas besoin de faire super.m2();
public void m2() { System.out.println("B.m1");
System.out.println("A.m2"); }
} }
} Résultat :
A : hello
// main B : hello
B b= new B("hello"); A.m1
b.m1(); A.m2
B.m1

ENSEM Java - JEE 63

 Modificateur final
⚫ final appliquée à une classe, indique qu’on ne peut pas
créer de classes dérivées pour cette classe.
⚫ final appliqué à un champ, indique que la valeur de ce
champ ne peut pas être modifiée après l'affectation initiale.
Permet de définir des valeurs constantes.
⚫ final appliqué à une méthode, indique que la méthode ne
peut pas être redéfinie dans une sous-classe.
⚫ Pour les paramètres d'une méthode, final indique que la
valeur de ces paramètres ne peut pas être modifiée.
⚫ Remarque : final permet au compilateur d'effectuer
certaines optimisations.
64
 super et this
⚫ Soit une classe B qui hérite d'une classe A

⚫ Dans une méthode d'instance m de B, « super. » sert à

désigner un membre de A

⚫ En particulier, super.m(…) désigne la méthode m de A qui

est en train d'être redéfinie dans B :

65
 super
⚫ une méthode static, ne peut être redéfinie.

⚫ super.m() ne doit pas exister pour une méthode static m() ;

⚫ On ne peut remonter plus haut que la classe mère pour

récupérer une méthode redéfinie :
• pas de cast « (ClasseAncetre)m() »
• pas de « super.super.m() »

66
 Polymorphisme
⚫ Si l'on considère le diagramme de classes suivant :

67
 Polymorphisme
⚫ Définition : la capacité de choisir dynamiquement la
méthode qui correspond au type réel de l'objet.

⚫ Si la classe Poisson hérite de la classe Animal

• classe Poisson "EST-UN" classe Animal
• toute méthode m de Animal peut-être invoquée sur une
instance de la classe poisson (héritage)

⚫ Le polymorphisme consiste à exploiter cela en fournissant

une sous-classe dans les expressions "qui attendent" une
classe mère.
⚫ une fille doit pouvoir faire tout ce que fait sa mère ;
68
 Polymorphisme
Animal anim1 = new Poisson( ) ; //un poisson est un animal
Animal anim2 = new Chien() ; //un chien est aussi un animal

System.out.println(anim1.mange());
System.out.println(anim2.mange());

// un animal n’est pas nécessairement un poisson

Poisson p=anim1;

69
 Polymorphisme
⚫ Quelle méthode mange() sera invoquée dans ce cas ?

⚫ C'est toujours la méthode mange() définie dans la sous-

classe qui sera invoquée.

⚫ Même si anim1 est une référence de type Animal, c'est le

type de l'objet référencé qui détermine la méthode qui
sera appelée.
⚫ En Java, lorsqu’il y a héritage, la détermination de la
méthode à invoquer n'est pas effectuée lors de la
compilation.

70
 Polymorphisme
⚫ C'est seulement à l'exécution que la machine virtuelle
déterminera la méthode à invoquer selon le type effectif de
l'objet référencé à ce moment là.

⚫ Ce mécanisme s'appelle "Recherche dynamique de

méthode" (Late Binding ou Dynamic Binding).

⚫ Ce mécanisme de recherche dynamique (durant l'exécution

de l'application) sert de base à la mise en œuvre de la
propriété appelée polymorphisme.

71
 Polymorphisme
⚫ On pourrait définir le polymorphisme comme la propriété
permettant à un programme de réagir différemment à
l'envoi d'un même message (invocation de méthode) en
fonction des objets qui reçoivent ce message.

⚫ Il s'agit donc d'une adaptation dynamique du

comportement selon les objets en présence.

⚫ Avec l'encapsulation et l'héritage, le polymorphisme est

une des propriétés essentielles de la programmation
orientée objet.

72
Polymorphisme
// Déclaration et création du tableau
Animal[ ] menagerie = new Animal[6];
// Alimentation du tableau
menagerie[0] = new Poisson(...);
menagerie[1] = new Chien(...);
menagerie[2] = new Chien(...);
menagerie[3] = new Animal(...);
menagerie[4] = new Poisson(...);
menagerie[5] = new Chien(...);

73
Polymorphisme

74
 Upcasting : classe fille →
classe mère
⚫ surclassement ou upcasting est le fait d'enregistrer une
référence d'une instance d'une classe B héritant d'une
classe A dans une variable de type A.

⚫ En java, cette opération est implicite et constitue la base du

polymorphisme.

75
 Downcasting : classe mère →
classe fille
⚫ déclassement ou downcasting est 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>).

76
 Downcasting
⚫ Attention : Le downcasting ne permet pas de convertir une
instance d'une classe donnée en une instance d'une sous-
classe !

77
 Interface: type abstrait

<<Interface>> AdaptateurWifi
⚫ Une interface est un type
{ envoyerDonner(..)
abstrait, censé être recevoirDonner(..) }
implémenté par des classes.
⚫ Il ne contient que les
méthodes sans corps.
⚫ Ces méthodes sont à redéfinir
dans les classes AdaptateurWifiImpl1 AdaptateurWifiImpl2
d'implémentation envoyerDonner(..) { envoyerDonner(…)
⚫ On ne peut pas créer une .. } {.. }
recevoirDonner(..) recevoirDonner(...)
instance d'une interface mais { .. }
on peut créer une instance { .. }
d'une classe
d'implémentation.

ENSEM Java - JEE 78

 Interface: héritage multiple
⚫ Une classe peut hériter de <<Interface>>
<<Interface>>
plusieurs interfaces. LecteurCD LecteurDVD
• Chaque interface lirePiste(…)
…
selectionnerLanguage();
…
représente un rôle d'une
classe.
• Ex. un Lecteur CD-DVD a
comme rôles LecteurCD
et LecteurDVD LecteurCdDvdImpl
lirePiste(…);
selectionnerLanguage(...);
….

ENSEM Java - JEE 79

 Interface: syntaxe

interface nom_de_l'interface [ extends noms

d'autres interfaces ] {
public void methode1(String param1) ;
public int methode2(int param1, int param2) ;

// autres méthodes …
}

⚫ Le mot clé "extends" permet à une interface

d'hériter d'autres interfaces (une ou plusieurs)

ENSEM Java - JEE 80

 Implémentation d'une interface
⚫ Une classe implémentant une interface doit redéfinir toutes
les méthodes déclarées dans l'interface.

public class LecteurCdDvdImpl

implements LecteurCD, LecteurDVD {

public void lirePiste(int noPiste) {

…. // à ¨spécifier
}
public void selectionnerLangue(String lang) {
…. // à spécifier
}

ENSEM Java - JEE 81

 Les classes abstraites
⚫ Une classe abstraite est incomplète
• Elle ne peut être utilisée telle quelle.
• Elle est censée être spécifiée par des sous classes.
• On ne peut pas créer une instance d'une classe abstraite.
⚫ Une classe abstraite peut avoir des méthodes
vides (à redéfinir par des sous-classes).

ENSEM Java - JEE 82

Exemple d'une classe abstraite
public abstract Fenetre {
// attributs génériques pour tout type de fenêtres.
int posX; int posY;
int dimX; int dimY;
// Les méthodes dont l'implémentation est générique
// (pour tout type de fenêtres).
public void deplacer() { … }
public void redimensionner(int newDimX, int newDimY) {
dimX = newDimX; dimY = newDimY;
rafraichirContenu();
}
// la méthode dont on ne connaît pas encore l'implémentation
// (cela dépend de type de fenêtre). Ainsi on la laisse vide.
public abstract rafraichirContenu();
}
ENSEM Java - JEE 83
 Visibilité: modificateur public/private
⚫ Le modificateur public marque que les attributs/ méthodes d'une
classe sont accessibles partout (dans les classes).
⚫ Le modificateur private marque que les attributs/ méthodes d'une
classe ne sont accessibles que dans cette classe.

class C2 {
void m3() {
class C1 { C1 c1 = new C1();
public String a1; c1.a1 = "hello"; // OK
private String a2; // c1.a2 = "hello"; illégal
public void m1(); c1.m1(); // OK
private void m2(); // c1.m2(); illégal
} }
}

ENSEM Java - JEE 84

 Visibilité :
autre modificateurs de visibilité
⚫ Les autres modificateurs sont:
• aucun modificateur (par défaut): les attributs/ méthodes sont
accessibles
• par les classes du même package
• protected: les attributs/ méthodes sont accessibles
• par les classes du même package, et
• par les sous-classes de la classe courante.

package p1; package p2;

public class A{ public class C {
int a1; // a1, a2 non accessible
protected int a2; }
}
public class D extends A {
public class B { // a1 non accessible
// a1, a2 accessible // a2 accessible
} }

ENSEM Java - JEE 85

 Encapsulation : principe
// pas d'encapsulation // modification illégale
public class Date { Date d1 = new Date();
public int jour; d1.jour = 23;
public int mois; d1.mois = 2;
public int annee; d1.annee = 2011;
}

⚫ Principe d'encapsulation :
• Une classe devrait cacher des attributs et exposer ses
méthodes au monde extérieur (aux autres classes)
• Protéger le contenu (les attributs) de la modification illégale
• Masquer les détails internes de la classe
→ simplification

ENSEM Java - JEE 86

 Encapsulation: Protection du contenu

public class Date { ⚫ Seule la

private int jour;
private int mois;
modification
private int annee; valide est
public Date() { permise
… // initialisé à la date aujourd'hui
}
public boolean setDate(int j, int m, int a) {
if( estDateValide(j, m, a) ) {
jour =j; moi=m; annee=a; return true;
} else { return false; }
}
…
}

ENSEM Java - JEE 87

 Encapsulation:
Masque de détails internes

public class Image {

// séquence d'octets au format propriétaire
private byte[] donnees;
public void chargerDeFichier(File ficher) {
… // charger et convertir au format propriétaire
}
public void afficher() {
…. // interpréter le format propriétaire.
}
}

⚫ L'utilisateur n’a pas besoin de connaître le

format de données pour utiliser cette classe

ENSEM Java - JEE 88

 Membres statiques
⚫ Le modificateur «static» peut s'appliquer à une
méthode ou à un attribut d’une classe.
• L'élément statique est partagé par toutes les instances
de la classe.
• Il est possible d’y accéder sans disposer d’une instance,
mais directement par la classe.
⚫ Ex : une méthode statique
// OK
public class Calculatrice {
public static int valeurAbsolue(int i )
System.out.println(
{ Calculatrice.valeurAbsolue(-25) );
if(i < 0) return -1 * i;
// pas besoin de faire cela:
return i;
Calculatrice c = new Calculatrice();
}
} System.out.println(
c.valeurAbsolue(-25) );

ENSEM Java - JEE 89

 Membres statiques: Exemple

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

static int comptoir = 0; // initialiser Test t1 = Test();
//lors du chargement de la classe Test t2 = Test();
int id; Test t3 = Test();
public Test() { Test.imprimerComptoir(); // résultat?
id = comptoir; // utiliser le comptoir t1.imprimerId(); // résultat ?
//comme identifiant d'objet t2.imprimerId(); // résultat ?
comptoir ++; //incrémenter le t3.imprimerId(); // résultat ?
//comptoir à chaque instanciation }
}
public imprimerId() {
System.out.println(id);
}
⚫ Les méthodes statiques ne
public static imprimerComptoir() { peuvent accéder qu’aux
System.out.println(comptoir); attributs statiques.
}
}

ENSEM Java - JEE 90

 Définition de constants
⚫ Un constant peut être défini comme un attribut d’une
classe, avec la déclaration <<static>> (partagée par
toutes les instances) et <<final>> (sa valeur est non
modifiable)
⚫ Par convention le nom d'un constant est tout en
majuscules.

public class MesConstants {

public static final int LOAD = 0;
public static final int SAVE = 0;
public static final int MOVE = 2;
}

ENSEM Java - JEE 91