Programmation Orientée Objet Java

Auteur : S. Amri

Université My Ismail 1
S. Amri
ENSAM Meknès
TC3A
Plan de cours
◼ Généralités sur Java
◼ Programmation orientée Objet Java
◼ Objet et Classe
◼ Héritage et accessibilité
◼ Polymorphisme
◼ Collections
◼ Gestion des exceptions

2
 Qu’est ce que java?

◼ Langage de programmation orienté objet (Classe, Objet,

Héritage, Encapsulation et Polymorphisme)
◼ Avec java on peut créer des applications
multiplateformes. Les applications java sont portables.
C’est-à-dire, on peut créer une application java dans une
plateforme donnée et on peut l’exécuter sur n’importe
quelle autre plateforme.
◼ Le principe de java est : Write Once Run Every Where
◼ Open source: On peut récupérer le code source de java.
Ce qui permet aux développeurs, en cas de besoin, de
développer ou modifier des fonctionnalités de java.

3
 Qu’est ce que java?
◼ Java est utilisé pour créer :
❑ Des applications Desktop
❑ Des applets java (applications java destinées à s’exécuter dans une page web)
❑ Des applications pour les smart phones
❑ Des applications embarquées dans des cartes à puces
❑ Des application JEE (Java Entreprise Edition)
◼ Pour créer une application java, il faut installer un kit de développement
java
❑ JSDK : Java Standard Developpement Kit, pour développer les application
DeskTop
❑ JME : Java Mobile Edition, pour développer les applications pour les
téléphones potables
❑ JEE : Java Entreprise Edition, pour développer les applications qui vont
s’exécuter dans un serveur d’application JEE (Web Sphere Web Logic,
JBoss).
❑ JCA : Java Card Editon, pour développer les applications qui vont
s’éxécuter dans des cartes à puces.

4
 Différents modes de compilation
Java est un langage compilé et interprété
▪ Compilation en mode natif
▪ Compilation Byte Code
▪ Compilation en mode JIT(Just In Time)

Natif Byte Code JIT

Code source Code source Code source

Compilation Compilation Compilation

Langage Machine Byte Code Byte Code

Edition de lien Interprétation par Interprétation par

La JVM en mode byte code La JVM en mode JIT
(Traduit en code machine (Traduit tout le programme
[Link] et exécute instruction par Byte Code en programme
Instruction )
10
◼ Le Kit de développement java JDK peut être téléchargé
gratuitement à partir du site de Oracle son éditeur
([Link]
◼ Le JDK contient 3 trois pacquages :
❑ [Link] : Kit de développement proprement dit
❑ [Link] : Machine virtuelle java

❑ [Link] : Documentation java

◼ Exécuter [Link] . Le JDK sera installé

◼ Les programmes nécessaires au développement java
sont placés dans le répertoire c:\jdk1.8\bin à savoir:
❑ [Link] : Compilateur java.
❑ [Link] : Interpréteur du bytecode java.
❑ [Link] : Pour tester les applets java.
❑ [Link] : Débogueur java.
❑ [Link] : désassembleur du bytecode.
❑ [Link] : Générer la documentation de vos programmes
java.
❑ [Link] : Permet de lier des programmes Java avec des
méthodes natives, écrites dans un autre langage et dépendant
du système.
❑ [Link] : Permet de compresser les classes Java ainsi que tous
les fichiers nécessaires à l'exécution d'un programme
(graphiques, sons, etc.). Il permet en particulier d'optimiser le
chargement des applets sur Internet.
❑ [Link] : Un utilitaire permettant de signer les fichiers
archives produits par [Link]

13
◼ La configuration de l'environnement comporte deux
aspects :
- Définir la variable d’environnement path qui indique
le chemin d'accès aux programmes exécutables :
Cette variable path devrait contenir le chemin du
JDK utilisé:
- path= C:\Program Files\Java\jdkxx\bin; ……..
- Quand elle exécute une application java, la JVM
consulte la variable d’environnement classpath qui
contient le chemin d’accès aux classes java
utilisées par cette application.
- classpath= .; c:\monProjet\lib; c:\programmat

14
◼ Un Editeur de texte ASCII: on peut utiliser un simple
éditeur comme notepad de windows mais il est
préférable d ’utiliser un éditeur conçu pour la
programmation java exemples: Ultraedit, JCreator, ….
◼ Eclipse est l’environnement de développement java le
plus préféré pour les développeurs java. Il est gratuit
et c’est un environnement ouvert.
◼ Autres IDE java :
❑ IntelliJ IDEA
❑ Eclipse
❑ JDevlopper de Oracle.
❑ JBuilder de Borland.

16
Premier programme java
Remarques :
◼ Le nom du fichier java doit être le même que celui de la classe
qui contient la fonction principale main.
◼ Pour compiler le programme source, il faut faire appel au
programme [Link] qui se trouve dans le dossier c:\jdk1.2\bin.
◼ Pour rendre accessible ce programme depuis n ’importe quel
répertoire, il faut ajouter la commande : path c:\jdk1.2\bin dans le
fichier [Link].
◼ Après compilation du programme [Link], il y a
génération du fichier [Link] qui représente le
ByteCode de programme.
◼ Pour exécuter ce programme en byte code, il faut faire appel au
programme [Link] qui représente l’interpréter du bytecode.

17
 Premier programme java
public class PremierProgramme {
public static void main(String[] args) {
[Link]("First Test");
}
}
◼ Lancer un éditeur de texte ASCII et Ecrire le code source de ce programme.
◼ Enregistrer ce fichier dans un nouveau répertoire c:\exojava sous le nom
[Link]
Compiler ce programme sur ligne de commande Dos :
c:\exojava>javac [Link]
Corriger les Erreurs de compilation
Exécuter le programme sur ligne de commande
c:\exojava>java PremierProgramme

18
Structures fondamentales du
langage java

19
Structure du langage java

◼ Au niveau syntaxe, Java est un langage de

programmation qui ressemble beaucoup au langage
C++
◼ Toutefois quelques simplifications ont été
apportées à java pour des raisons de sécurité et
d’optimisation.
◼ Dans cette partie nous ferons une présentation
succincte des types primitifs, les enveloppeurs,
déclarations des variables, le casting des primitives,
les opérateurs arithmétiques et logiques, les
structures de contrôle (if, swich, for et while)

20
Les primitives

Java dispose des primitives suivantes :

Primitive Étendue Taille

char 0 à 65 535 16 bits

byte -128 à +127 8 bits
short -32 768 à +32 767 16 bits
Int -2 147 483 648 à + 2 147 483 647 32 bits
Long 64 bits
Float de ± 1.4E-45 à ± 3.40282347E38 32 bits
Double 64 bits
Boolean true ou false 1 bit
Void - 0 bit

21
 Utilisation des primitives
◼ Les primitives sont utilisées de façon très simple. Elles
doivent être déclarées, tout comme les handles d'objets,
avec une syntaxe similaire, par exemple :
❑ int i;
❑ char c;

❑ boolean fini;

◼ Les primitives peuvent être initialisées en même temps que

la déclaration.
❑ int i = 12;
❑ char c = 'a';
❑ boolean fini = true;

22
Utilisation des primitives
◼ Comment choisir le nom d’une variable:
❑ Pour respecter la typologie de java, les nom des
variables commencent toujours par un caractère en
minuscule et pour indiquer un séparateur de mots,on
utilise les majuscules. Exemples:
❑ int nbPersonnes;
❑ String nomPersonne;
◼ Valeurs par défaut des primitives:
❑ Toutes les primitives de type numérique utilisées
comme membres d'un objet sont initialisées à la
valeur 0. Le type boolean est initialisé à la valeur
false.

23
Casting des primitives

◼ Le casting des primitives

❑ Le casting (mot anglais qui signifie moulage),
également appelé cast ou, parfois, transtypage,
consiste à effectuer une conversion d'un type vers un
autre type.
❑ Le casting peut être effectué dans deux conditions
différentes
◼ Vers un type plus général. On parle alors de sur-casting ou
de sur-typage.
◼ Vers un type plus particulier. On parle alors de sous- casting
ou de sous-typage.

24
Casting des primitives
◼ Sur-casting : Le sur-casting peut se faire
implicitement ou explicitement.
❑ Exemples :
◼ int a=6; // le type int est codé sur 32 bits
◼ long b; // le type long est codé sur 64 bits
❑ Casting implicite :
▪ b=a;
❑ Casting explicite
▪ b=(long)a;
◼ Sous-Casting : Le sous-casting ne peut
se faire qu’explicitement.
1: float a = (float)5.5;
2 : double c = (double)a;
4 : int d = 8;
5 : byte f = (byte)d;

25
Les enveloppeurs (wearpers)
Les primitives sont enveloppées dans des objets appelés
enveloppeurs (Wearpers ). Les enveloppeurs sont des classe
Classe Primitive
Character char
Byte byte
Short short
Integer int
Long long
Float float
Double double
Boolean boolean
Void -
BigInteger - -
BigDecimal -

26
Utilisation des primitives et enveloppeurs
◼ Exemple:
❑ double v1=5.5; // v1 est une primitive
❑ Double v2=new Double(5.6); // v2 est un objet
❑ long a=5; // a est une primitive
❑ Long b=new Long(5); // b est un objet
❑ Long c= 5L; // c est un objet
❑ [Link]("a="+a);
❑ [Link]("b="+[Link]());
❑ [Link]("c="+[Link]());
❑ [Link]("V1="+v1);
❑ [Link]("V2="+[Link]());
◼ Résultat:
❑ a=5

❑ b=5

❑ c=5

❑ V1=5.5

❑ V2=5

27
 Opérateurs
◼ Opérateur d ’affectation:
• x=3; // x reçoit 3
• x=y=z=w+5; // z reçoit w+5, y reçoit z et x reçoit y
◼ Les opérateurs arithmétiques à deux opérandes:
• + : addition
• - : soustraction
• * : multiplication
• / : division
• % : modulo (reste de la division euclidienne)

28
Opérateurs
◼ Les opérateurs arithmétiques à deux opérandes
(Les raccourcis)
x = x + 4; ou x+=4;
z = z * y; ou Z*=y;
v = v % w; ou v%=w;
◼ Les opérateurs relationnels:
• == : équivalent
• < : plus petit que
• > : plus grand que
• <= : plus petit ou égal
• >= : plus grand ou égal
• != : non équivalent
◼ Les opérateurs d’incrémentations et de
décrémentation:
❑ ++ : Pour incrémenter (i++ ou ++i)
❑ -- : Pour décrémenter (i–- ou --i)

29
Opérateurs
◼ Les opérateurs logiques
❑ && Et (deux opérandes)
❑ || Ou (deux opérandes)
❑ ! Non (un seul opérande)
◼ L'opérateur à trois opérandes ?:
❑ condition ? expression_si_vrai : expression_si_faux
exemple : x = (y < 5) ? 4 * y : 2 * y;
Equivalent à :
if (y < 5)
x = 4 * y;
else
x = 2 * y;

30
Structures de contrôle
◼ L'instruction conditionnelle if
La syntaxe de l'instruction if peut être décrite de la façon suivante:
if (expression) instruction;
ou:
if (expression) {
instruction1;
instruction2;
}
◼ L'instruction conditionnelle else
if (expression) {
instruction1;
}
else {
instruction2;
}

31
 Structures de contrôle
◼ Les instructions conditionnelles imbriquées
Java permet d'écrire ce type de structure sous la forme :
if (expression1) {
bloc1;
}
else if (expression2) {
bloc2;
}
else if (expression3) {
bloc3;
}
else {
bloc5;
}

32
Structures de contrôle: L'instruction switch
Syntaxe :
switch( variable) {
case valeur1: instr1;break;
case valeur2: instr2;break;
◼ Exemple: case valeurN: instrN;break;
import [Link]; default: instr;break;
public class Test { }

public static void main(String[] args) {

[Link]("Donner un nombre:");
Scanner clavier=new Scanner([Link]);
int nb=[Link]();
switch(nb){
case 1 : [Link]("Lundi");break;
case 2 : [Link]("Mardi");break;
case 3 : [Link]("Mercredi");break;
default :[Link]("Autrement");break;
}}}
33
 Structures de contrôle
◼ La boucle for
La boucle for est une structure employée pour exécuter un bloc
d'instructions un nombre de fois en principe connu à l'avance.
Elle utilise la syntaxe suivante :
for (initialisation;test;incrémentation) {
instructions;
}
Exemple :
for (int i = 2; i < 10;i++) {
[Link]("I="+i);
}

34
Structures de contrôle
◼ Sortie d'une boucle par return
int[] tab=new int[]{4,6,5,8};
for (int i = 0; i < [Link]; i++) {
if (tab[i] == 5) {
return i;
}
◼ Branchement au moyen des instructions break et continue
❑ break:
int x = 10;
for (int i = 0; i < 10; i++) {
x--;
if (x == 5) break;
}
[Link](x);
❑ continue:
for (int i = 0; i < 10; i++) {
if (i == 5) continue;
[Link](i);
}
35
 Structures de contrôle
◼ L ’instruction While
while (condition){ Exemple :
int s=0;int i=0;
BlocInstructions; while (i<10){
} s+=i;
i++;

[Link]("Somme="+s);
◼ L ’instruction do ..
while Exemple :
do{ int s=0;int i=0;
BlocInstructions; do{
s+=i;
}
i++;
while (condition); }while (i<10);
[Link]("Somme="+s);

36
Programmation orientée objet
avec JAVA

37
Méthode orientée objet
◼ La méthode orientée objet permet de concevoir une application sous
la forme d'un ensemble d'objets reliés entre eux par des relations
◼ Lorsque que l'on programme avec cette méthode, la première
question que l’on se pose plus souvent est :
❑ «qu'est-ce que je manipule ? »,
❑ Au lieu de « qu'est-ce que je fais? ».
◼ L'une des caractéristiques de cette méthode permet de concevoir de
nouveaux objets à partir d'objets existants.
◼ On peut donc réutiliser les objets dans plusieurs applications.
◼ La réutilisation du code fut un argument déterminant pour venter les
avantages des langages à objets.
◼ Pour faire la programmation orientée objet il faut maitriser les
fondamentaux de l’orienté objet à savoir :
❑ Objet et classe
❑ Héritage
❑ Encapsulation (Accessibilité)
❑ Polymorphisme

38
Objet
◼ Un objet est une structure informatique définie par un état et un
comportement
◼ Objet=état + comportement
❑ L’état regroupe les valeurs instantanées de tous les attributs de l’objet.
❑ Le comportement regroupe toutes les compétences et décrit les actions
et les réactions de l’objet. Autrement dit le comportement est défini par
les opérations que l’objet peut effectuer.
◼ L’état d’un objet peut changer dans le temps.
◼ Généralement, c’est le comportement qui modifie l’état de l’objet
◼ Exemples:

v1:Voiture :Fenetre

Couleur="rouge" titre="WinWord"
État de l’objet largeur=400
Carburant=20
Puissance=120 hauteur=300

demarrer() Deplacer()

accelerer() Comportement agrandir()

Freiner() fermer()
42
Identité d’un objet

◼ En plus de son état, un objet possède une identité

qui caractérise son existence propre.
◼ Cette identité s’appelle également référence ou
handle de l’objet
◼ En terme informatique de bas niveau, l’identité d’un
objet représente son adresse mémoire.
◼ Deux objets ne peuvent pas avoir la même identité:
c’est-à-dire que deux objets ne peuvent pas avoir
le même emplacement mémoire.

43
Classes

◼ Les objets qui ont des caractéristiques communes

sont regroupés dans une entité appelé classe.
◼ La classe décrit le domaine de définition d’un
ensemble d’objets.
◼ Chaque objet appartient à une classe
◼ Les généralités sont contenues dans les classes
et les particularités dans les objets.
◼ Les objets informatiques sont construits à partir
de leur classe par un processus qui s’appelle
l’instanciation.
◼ Tout objet est une instance d’une classe.

44
Caractéristique d’une classe
◼ Une classe est définit par:
❑ Les attributs
❑ Les méthodes
◼ Les attributs permettent de décrire l’état de des objets de cette classe.
❑ Chaque attribut est défini par:
◼ Son nom
◼ Son type
◼ Éventuellement sa valeur initiale
◼ Les méthodes permettent de décrire le comportement des objets de
cette classe.
❑ Une méthode représente une procédure ou une fonction qui permet
d’exécuter un certain nombre d’instructions.
◼ Parmi les méthode d’une classe, existe deux méthodes particulières :
❑ Une méthode qui est appelée au moment de la création d’un objet de
cette classe. Cette méthode est appelée CONSTRUCTEUR
❑ Une méthode qui est appelée au moment de la destruction d’un objet.
Cette méthode s’appelle le DESTRUCTEUR

45
Représentation UML d’une classe

◼ Une classe est représenté par un rectangle à 3

compartiments:
❑ Un compartiment qui contient le nom de la classe
❑ Un compartiment qui contient la déclaration des attributs
❑ Un compartiment qui contient les méthodes
Exemples:
Compte Nom de la classe

code : int
Attributs
solde : float
Compte(float soldeInitial) Méthodes
verser(float mt):void Ou
Opérations
retirer(float mt):void
getSolde():float
46
Les classes sont stockées dans des packages

◼ Les packages offrent un mécanisme général pour la partition des

modèles et le regroupement des éléments de la modélisation
◼ Chaque package est représenté graphiquement par un dossier
◼ Les packages divisent et organisent les modèles de la même
manière que les dossier organisent le système de fichier

Nom
du paquetage

47
 Accessibilité au membres d’une classe
◼ Dans java, il existe 4 niveaux de protection :
❑ private (-) : Un membre privé d’une classe n’est
accessible qu’à l’intérieur de cette classe.
❑ protected (#) : un membre protégé d’une classe est
accessible à :
◼ L’intérieur de cette classe
◼ Aux classes dérivées de cette classe.
◼ Aux classes du même package.
❑ public (+) : accès à partir de toute entité interne ou
externe à la classe
❑ Autorisation par défaut : dans java, en l’absence
des trois autorisations précédentes, l’autorisation par
défaut est package. Cette autorisation indique que
uniquement les classes du même package ont
l’autorisation d’accès.

48
 Exemple d’implémentation d’une classe
avec Java package metier;
public class Compte {
// Attributs
metier private int code;
protected float solde;
Compte // Constructeur
- code : int public Compte(int c,float s){
code=c;
# solde : float
solde=s;
+ Compte(int code, float solde) }
+ verser(float mt):void // Méthode pour verser un montant
public void verser(float mt){
+ retirer(float mt):void
solde+=mt;
+ toString():String }
// Méthode pour retirer un montant
public void retirer(float mt){
solde-=mt;
}
// Une méthode qui retourne l'état du compte
public String toString(){
return(" Code="+code+" Solde="+solde);
}
} 49
 Création des objets dans java
◼ Dans java, pour créer un objet d’une classe , On utilise la commande
new suivie du constructeur de la classe.
◼ La commande new Crée un objet dans l’espace mémoire et retourne
l’adresse mémoire de celui-ci.
◼ Cette adresse mémoire devrait être affectée à une variable qui
représente l’identité de l’objet. Cette référence est appelée handle.
package test;
import [Link]; c1:Compte
c1:Compte
public class Application { Code=1
code=1
public static void main(String[] args) { Solde=8
5000
solde=6000

Compte c1=new Compte(1,5000); verser(float m

verser(float t)
mt)
retirer(float mt)
retirer(float mt)
Compte c2=new Compte(2,6000);
toString()
toString()
[Link](3000);
c2:Compte
[Link](2000);
code=2
[Link]([Link]()); solde=6000
} verser(float mt)

} Code=1 Solde= 6000 retirer(float mt)

toString() 50
 Constructeur par défaut
◼ Quand on ne définit aucun constructeur pour une classe, le
compilateur crée le constructeur par défaut.
◼ Le constructeur par défaut n’a aucun paramètre et ne fait
aucune initialisation
Exemple de classe : Instanciation en utilisant le
public class Personne { constructeur par défaut :
// Les Attributs
private int code; Personne p=new Personne();
private String nom; [Link]("AZER");
// Les Méthodes [Link]([Link]());
public void setNom(String n){
[Link]=n;
}
public String getNom(){
return nom;
}
} 51
 Getters et Setters
◼ Les attributs privés d’une classe ne sont accessibles qu’à l’intérieur de la classe.
◼ Pour donner la possibilité à d’autres classes d’accéder aux membres privés, il
faut définir dans la classes des méthodes publiques qui permettent de :
❑ lire la variables privés. Ce genre de méthodes s’appellent les accesseurs ou Getters
❑ modifier les variables privés. Ce genre de méthodes s’appellent les mutateurs ou
Setters
◼ Les getters sont des méthodes qui commencent toujours par le mot get et
finissent par le nom de l’attribut en écrivant en majuscule la lettre qui vient juste
après le get. Les getters retourne toujours le même type que l’attribut
correspondant.
❑ Par exemple, dans la classe CompteSimple, nous avons défini un attribut privé :
private String nom;
❑ Le getter de cette variable est :
public String getNom( ){
return nom;
}
◼ Les setters sont des méthodes qui commencent toujours par le mot set et
finissent par le nom de l’attribut en écrivant en majuscule la lettre qui vient juste
après le set. Les setters sont toujours de type void et reçoivent un paramètre
qui est de meme type que la variable:
❑ Exemple:
public void setNom( String n ){
[Link]=n;
}
52
 Encapsulation Diagramme de séquence :
public class Application {
:Application
public static void main(String[] args) {
Personne p=new Personne(); créer()
[Link]("AZER"); p1:Personne
[Link]([Link]());
setNom("AZER")

getNom()
p:Personne
:Application
Comportement
Comportement
Etat
Etat
Code = 1
[Link]() nom=AZER

Retourne AZER
setNom()
[Link]("AZER")

Généralement, l’état d’un objet est privé ou protégé et son comportement est publique
Quand l’état de l’objet est privé Seules les méthode de ses qui ont le droit d’y accéder
Quand l’état de l’objet est protégé, les méthodes des classes dérivées et les classes
appartenant au même package peuvent également y accéder
53
Membres statiques d’une classe.
◼ Dans l’exemple de la classe Compte, chaque objet Compte
possède ses propres variables code et solde. Les variables code
et solde sont appelées variables d’instances.
◼ Les objets d’une même classe peuvent partager des mêmes
variables qui sont stockées au niveau de la classe. Ce genre de
variables, s’appellent les variables statiques ou variables de
classes.
◼ Un attribut statique d’une classe est un attribut qui appartient à la
classe et partagé par tous les objets de cette classe.
◼ Comme un attribut une méthode peut être déclarée statique, ce
qui signifie qu’elle appartient à la classe et partagée par toutes
les instances de cette classe.
◼ Dans la notation UML, les membres statiques d’une classe sont
soulignés.

54
◼
Exemple:
Supposant nous voulions ajouter à la
package metier;
public class Compte {
classe Compte une variable qui permet // Variables d’instances
de stocker le nombre le comptes créés. private int code;
◼ Comme la valeur de variable nbComptes private float solde;
est la même pour tous les objets, celle-ci // Variable de classe ou statique
sera déclarée statique. Si non, elle sera private static int nbComptes;
dupliquée dans chaque nouveau objet public Compte(float solde){
créé. [Link]=++nbComptes;
[Link]=solde;
◼ La valeur de nbComptes est au départ
}
initialisée à 0, et pendant la création
// Méthode pour verser un montant
d’une nouvelle instance (au niveau du
public void verser(float mt){
constructeur), nbCompte est incrémentée
solde+=mt;
et on profite de la valeur de nbComptes
pour initialiser le code du compte. }
// Méthode pour retirer un montant
Compte public void retirer(float mt){
solde-=mt;
- code : int
}
# solde : float // retourne l'état du compte
public String toString(){
- nbComptes:int
return(" Code="+code+" Solde="+solde);
+ Compte(float solde) }
// retourne la valeur de nbComptes
+ verser(float mt):void
public static int getNbComptes(){
+ retirer(float mt):void return(nbComptes);
}
+ toString():String
}
+ getNbComptes():int 55
 Application de test Classe C
Classe ompte
Compte
n 0
nbCompte=2
bCompte=1
package test;
import [Link];
getNbComptes()
getNbComptes()
public class Application {
public static void main(String[] args) {

Compte c1=new Compte(5000); c1:Compte

c1:Compte c2:Compte
Compte c2=new Compte(6000); Code=1
code=1 code=2
Solde=8
5000
solde=6000 solde=6000
[Link](3000);
verser(float mt)
verser(float mt) verser(float mt)
[Link](2000); retirer(float mt)
retirer(float mt) retirer(float mt)
[Link]([Link]()); toString()
toString() toString()

[Link]([Link])
[Link]([Link])
}
}
Code=1 Solde= 6000
2
2 56
Destruction des objets : Garbage Collector
◼ Dans certains langages de programmation, le
programmeur doit s’occuper lui même de détruire les
objets inutilisables.
◼ Java détruit automatiquement tous les objets
inutilisables en utilisant ce qu ’on appelle le garbage
collector (ramasseur d ’ordures). Qui s ’exécute
automatiquement dès que la mémoire disponible est
inférieure à un certain seuil.
◼ Tous les objets qui ne sont pas retenus par des
handles seront détruits.
◼ Ce phénomène ralenti parfois le fonctionnement de
java.
◼ Pour signaler au garbage collector que vous vouler
détruire un objet d’une classe, vous pouvez faire appel
à la méthode finalize() redéfinie dans la classe.

57
 Exercice 1 : Modélisation d’un segment
extr1 extr2
◼ On souhaite créer une application qui permet de manipuler des segments.
◼ Un segment est défini par la valeur de ses deux extrémités extr1 et extr2.
◼ Pour créer un segment, il faut préciser les valeurs de extr1 et extr2.
◼ Les opérations que l’on souhaite exécuter sur le segment sont :
❑ ordonne() : méthode qui permet d’ordonner extr1 et extr2 si extr1 est supérieur à
extr2
❑ getLongueur() : méthode qui retourne la longueur du segment.
❑ appartient(int x) : retourne si x appartient au segment ou non.
❑ toString() : retourne une chaîne de caractères de type SEGMENT[extr1,extr2]
◼ Faire une représentation UML de la classe Segment.
◼ Implémenter en java la classe Segment
◼ Créer une application TestSegment qui permet de :
❑ Créer objet de la classe Segment avec les valeurs extr1=24 et extr2=12.
❑ Afficher l’état de cet objet en utilisant la méthode toString().
❑ Afficher la longueur de ce segment.
❑ Afficher si le point x=15, appartient à ce segment.
❑ Changer les valeurs des deux extrémités de ce segment.
❑ Afficher à nouveau la longueur du segment.
58
Diagramme de classes
Segment TestSegment
+ extr1 : int
+ extr2 : int + main(String[] args):void
+ Segment (int e1,int e2)
+ ordonne()
+ getLongueur() : int
+ appartient(int x) : boolean
+ toString() : String

59
Solution : [Link]
package fig;
public class Segment {
public int extr1;
public int extr2;
// Constructeur
public Segment(int a,int b){
extr1=a;extr2=b;ordonne();
}
public void ordonne(){
if(extr1>extr2){
int z=extr1;
extr1=extr2;
extr2=z;
}
}
public int getLongueur(){
return(extr2-extr1);
}
public boolean appartient(int x){
if((x>extr1)&&(x<extr2))
return true;
else return false;
}
public String toString(){
return ("segment["+extr1+","+extr2+"]");
}
60
}
 Donner Extr1:67
Application Donner Extr2:13
Longueur dusegment[13,67] est :54
Donner X:7
package test;
7 N'appartient pas au segment[13,67]
import [Link];
import [Link];
public class Application {
public static void main(String[] args) {
Scanner clavier=new Scanner([Link]);
[Link]("Donner Extr1:");int e1=[Link]();
[Link]("Donner Extr2:");int e2=[Link]();
Segment s=new Segment(e1, e2);
[Link]("Longueur du"+[Link]()+" est :"+
[Link]());
[Link]("Donner X:");int x=[Link]();
if([Link](x)==true)
[Link](x+" Appartient au "+s);
else
[Link](x+" N'appartien pas au "+s);
}
}
61
 Exécution de la classe TestSegment
Pour exécuter une application
(Classe qui contient la méthode
main) avec Eclipse, on clique
avec le bouton droit de la souris
sur la classe, puis on choisit
dans le menu contextuel, Run
As > Java Application

Donner Extr1:67
Donner Extr2:13
Longueur dusegment[13,67] est :54
Donner X:7
7 N'appartient pas au segment[13,67]

62
 Exercice 2
P(x,y)
◼ Une cercle est défini par :
R
▪ Un point qui représente son centre : centre(x,y) et un rayon.
◼ On peut créer un cercle de deux manières :
▪ Soit en précisant son centre et un point du cercle. C(x,y)

▪ Soit en précisant son centre et son rayon

◼ Les opérations que l’on souhaite exécuter sur un cercle sont :
▪ getPerimetre() : retourne le périmètre du cercle
▪ getSurface() : retourne la surface du cercle.

▪ appartient(Point p) : retourne si le point p appartient ou non à l’intérieur du cercle.

▪ toString() : retourne une chaîne de caractères de type CERCLE(x,y,R)
1. Etablir le diagramme de classes
2. Créer les classe Point définie par:
◼ Les attributs x et y de type int
◼ Un constructeur qui initialise les valeurs de x et y.
◼ Une méthode toString().
3. Créer la classe Cercle
4. Créer une application qui permet de :
a. Créer un cercle défini par le centre c(100,100) et un point p(200,200)
b. Créer un cercle défini par le centre c(130,100) et de rayon r=40
c. Afficher le périmètre et le rayon des deux cercles.
d. Afficher si le point p(120,100) appartient à l’intersection des deux cercles ou non.
63
Héritage et accessibilité

64
Héritage

◼ Dans la programmation orientée objet, l’héritage

offre un moyen très efficace qui permet la
réutilisation du code.
◼ En effet une classe peut hériter d’une autre classe
des attributs et des méthodes.
◼ L’héritage, quand il peut être exploité, fait gagner
beaucoup de temps en termes de
développement et en termes de maintenance des
applications.
◼ La réutilisation du code fut un argument déterminant
pour inventer les méthodes orientées objets.
65
Héritage

66
Exemple de problème
◼ Supposons que nous souhaitions créer une application qui permet de
manipuler différents types de comptes bancaires : les comptes
simples, les comptes épargnes et les comptes payants.
◼ Tous les types de comptes sont caractériser par:
❑ Un code et un solde
❑ Lors de la création d’un compte, son code qui est défini automatiquement en
fonction du nombre de comptes créés;
❑ Un compte peut subir les opérations de versement et de retrait. Pour ces
deux opérations, il faut connaître le montant de l’opération.
❑ Pour consulter un compte on peut faire appel à sa méthode toString()
◼ Un compte simple est un compte qui possède un découvert. Ce qui
signifie que ce compte peut être débiteur jusqu’à la valeur du
découvert.
◼ Un compte Epargne est un compte bancaire qui possède en plus un
champ «tauxInterêt» et une méthode calculIntérêt() qui permet de
mettre à jour le solde en tenant compte des interêts.
◼ Un ComptePayant est un compte bancaire pour lequel chaque
opération de retrait et de versement est payante et vaut 5 % du
montant de l’opération.

67
 Diagramme de classes
Compte
- code : int
# solde : float
- nbComptes : int

+ Compte ( )
+ verser (float mt) : void
+ retirer (float mt) : void
+ toString() : String

CompteSimple CompteEpargne ComptePayant

- decouvert : float - taux : float

+ CompteSimple (float dec) + CompteEparge (float taux) + ComptePayant ( )

+ retirer (float mt) : void + catculInterets () : void + verser (float mt) : void
+ toString() : String + toString() : String + retirer (float mt) : void
+ toString() : String

68
Implémentation java de la classe Compte
public class Compte {
private int code;
protected float solde;
private static int nbComptes;

public Compte( ){
++nbComptes;
code=nbComptes;
[Link]=0;
}
public void verser(float mt){
solde+=mt;
}
public void retirer(float mt){
if(mt<solde) solde-=mt;
}
public String toString(){
return("Code="+code+" Solde="+solde);
}
}

69
Héritage : extends
◼ La classe CompteSimple est une classe qui hérite de la classe
Compte.
◼ Pour désigner l’héritage dans java, on utilise le mot extends
public class CompteSimple extends Compte {

}
◼ La classe CompteSimple hérite de la classe CompteBancaire
tout ses membres sauf le constructeur.
◼ Dans java une classe hérite toujours d’une seule classe.
◼ Si une classe n’hérite pas explicitement d’une autre classe, elle
hérite implicitement de la classe Object.
◼ La classe Compte hérite de la classe Object.
◼ La classe CompteSimple hérite directement de la classe Compte
et indirectement de la classe Object.

70
Définir les constructeur de la classe dérivée
◼ Le constructeur de la classe dérivée peut
faire appel au constructeur de la classe
parente en utilisant le mot super() suivi de
ses paramètres.
public class CompteSimple extends Compte {
private float decouvert;
//constructeur
public CompteSimple(float decouvert){
super();
[Link]=decouvert;
}
}

71
Redéfinition des méthodes
◼ Quand une classe hérite d’une autre classe, elle peut redéfinir
les méthodes héritées.
◼ Dans notre cas la classe CompteSimple hérite de la classe
Compte la méthode retirer(). nous avons besoin de redéfinir
cette méthode pour prendre en considération la valeur du
découvert.
public class CompteSimple extends Compte {
private float decouvert;
// constructeur
public CompteSimple(float decouvert){
super();
[Link]=decouvert;
}
// Redéfinition de la méthode retirer
public void retirer(float mt) {
if(mt-decouvert<=solde)
solde-=mt;
}
} 71
 Redéfinition des méthodes
◼ Dans la méthode redéfinie de la nouvelle classe dérivée, on peut
faire appel à la méthode de la classe parente en utilisant le mot
super suivi d’un point et du nom de la méthode
◼ Dans cette nouvelle classe dérivée, nous allons redéfinir également
la méthode toString().
public class CompteSimple extends Compte {
private float decouvert;

// constructeur
// Redéfinition de la méthode retirer
public void retirer(float mt) {
if(mt+decouvert>solde)
solde-=mt;
}
// Redéfinition de la méthode toString
public String toString() {
return("Compte Simple "+[Link]()+"
Découvert="+decouvert);
}
}
72
Héritage à la loupe : Instanciation
: Compte
◼ Quand on crée une instance d’une
- code=1
classe, la classe parente est
- solde=0
automatiquement instanciée et l’objet
+ verser()
de la classe parente est associé à + retirer()
l’objet créé à travers la + toString()
référence « super » injectée par le
compilateur
CompteSimple cs=new CompteSimple(5000);
cs : CompteSimple
◼ Lors de l’instanciation, l’héritage entre - decouvert=5000
les classes est traduit par une - super =
composition entre un objet de la classe + retirer()
instanciée et d’un objet de la classe + toString()
parente qui est créé implicitement.

73
Surcharge
◼ Dans une classe, on peut définir plusieurs constructeurs. Chacun
ayant une signature différentes (paramètres différents)
◼ On dit que le constructeur est surchargé
◼ On peut également surcharger une méthode. Cela peut dire
qu’on peut définir, dans la même classe plusieurs méthodes qui
ont le même nom et des signatures différentes;
◼ La signature d’une méthode désigne la liste des arguments avec
leurs types.
◼ Dans la classe CompteSimple, par exemple, on peut ajouter un
autre constructeur sans paramètre
◼ Un constructeur peut appeler un autre constructeur de la même
classe en utilisant le mot this() avec des paramètres éventuels

74
 Surcharge de constructeurs
public class CompteSimple extends Compte {
private float decouvert;
//Premier constructeur
public CompteSimple(float decouvert){
super();
[Link]=decouvert;
}
//Deuxième constructeur
public CompteSimple(){
this(0);
}
}

On peut créer une instance de la classe CompteSimple en faisant appel

à l’un des deux constructeur :
CompteSimple cs1=new CompteSimple(5000);
CompteSimple cs2=new CompteSimple();

75
Accessibilité

76
Accessibilité
◼ Les trois critères permettant d'utiliser une classe sont Qui, Quoi,
Où. Il faut donc :
❑ Que l'utilisateur soit autorisé (Qui).

❑ Que le type d'utilisation souhaité soit autorisé (Quoi).

❑ Que l'adresse de la classe soit connue (Où).

◼ Pour utiliser donc une classe, il faut :

❑ Connaitre le package ou se trouve la classe (Où)
◼ Importer la classe en spécifiant son package.
❑ Qu’est ce qu’on peut faire avec cette classe:
◼ Est-ce qu’on a le droit de l’instancier
◼ Est-ce qu’on a le droit d’exploiter les membres de ses instances
◼ Est-ce qu’on a le droit d’hériter de cette classe.
◼ Est-ce qu’elle contient des membres statiques
❑ Connaitre qui a le droit d’accéder aux membres de cette
instance.

77
Les packages (Où)
◼ Nous avons souvent utilisé la classe System pour
afficher un message : [Link]() ,
◼ En consultant la documentation de java, nous allons
constater que le chemin d ’accès complet à la classe
System est [Link].
◼ La classe System étant stockée dans le sous dossier
lang du dossier java.
◼ [Link] est le chemin d ’accès qui présente
la particularité d ’utiliser un point « . » comme
séparateur.
◼ [Link] qui contient la classe System est appelé
« package

78
Les packages
◼ Notion de package:
❑ Java dispose d'un mécanisme pour la recherche des classes.
❑ Au moment de l’exécution, La JVM recherche les classes en priorité :
◼ Dans le répertoire courant, c'est-à-dire celui où se trouve la classe
appelante, si la variable d'environnement CLASSPATH n'est pas
définie ;
◼ Dans les chemins spécifiés par la variable d'environnement
CLASSPATH si celle-ci est définie.
◼ L’instruction package:
❑ Si vous souhaitez qu'une classe que vous avez créée appartienne à un
package particulier, vous devez le spécifier explicitement au moyen de
l'instruction package, suivie du nom du package.
❑ Cette instruction doit être la première du fichier.
❑ Elle concerne toutes les classes définies dans ce fichier.
◼ L’instruction import
❑ Pour utiliser une classe, il faut
◼ Soit écrire le nom de la classe précédée par son package.
◼ Soit importer cette classe en la déclarant dans la clause import. Et dans
ce cas là, seul le nom de la classe suffit pour l’utiliser.
79
 Application: package test;
import [Link];
public class Application {
package a.b.c; public static void main(String[] args) {
public class Client { Client c=new Client(2,"Salih");
private int code; [Link]("Nom="+[Link]());
private String nom;
public Client(int code, String nom) { }
[Link] = code; }
[Link] = nom;
}
public String getNom(){
return(nom);
}
public int getCode(){
return code;
}
}

◼ Pour Compiler la classe [Link] sur ligne de commande:

❑ javac -d cheminbin [Link]
❑ cheminbin représente le dossier des fichiers .class.

80
 Les packages (Où)
◼ Les fichiers .jar
– Les fichiers .jar sont des fichiers compressés comme les fichiers .zip selon un
algorithme particulier devenu un standard.
– Ils sont parfois appelés fichiers d'archives ou, plus simplement, archives. Ces
fichiers sont produits par des outils de compression tels que Pkzip (sous DOS) ou
Winzip (sous Windows), ou encore par [Link].
– Les fichiers .jar peuvent contenir une multitude de fichiers compressés avec
l'indication de leur chemin d'accès.
– Les packages standard de Java sont organisés de cette manière, dans un fichier
nommé [Link] placé dans le sous-répertoire lib du répertoire où est installé le JDK.
– Dans le cas d'une installation standard de Java 6 sur le disque C:, le chemin d'accès
complet à la classe System est donc : c:\jdk1.6\jre\lib\[Link]\java\lang\System
◼ Création de vos propres fichiers .jar ou .zip
❑ Vous pouvez utiliser le programme [Link] du jdk pour créer les fichiers
.jar
❑ Syntaxe : jar [options] [Link] fichiers
❑ Exemple qui permet d’archive le contenu du dossier a :
◼ C:\AJ2\TP_ACC\bin> jar cf [Link] a

81
Ce qui peut être fait(Quoi)
◼ Nous avons maintenant fait le tour de la question Où ?
◼ Pour qu'une classe puisse être utilisée (directement ou par
l'intermédiaire d'un de ses membres), il faut non seulement être
capable de la trouver, mais aussi qu'elle soit adaptée à l'usage
que l'on veut en faire.
◼ Une classe peut servir à plusieurs choses :
❑ Créer des objets, en étant instanciée.

❑ Créer de nouvelles classes, en étant étendue.

❑ On peut utiliser directement ses membres statiques (sans qu'elle

soit instanciée.)
❑ On peut utiliser les membres de ses instances.

◼ Les différents modificateurs qui permettent d’apporter des

restrictions à l’utilisation d’une classe sont:
❑ abstract, final, static, synchronized et native

82
Classe abstraite
◼ Une classe abstraite est une classe qui ne peut pas être
instanciée.
◼ La classe Compte de notre modèle peut être déclarée
abstract pour indiquer au compilateur que cette classe ne
peut pas être instanciée.
◼ Une classe abstraite est généralement créée pour en faire
dériver de nouvelle classe par héritage.
public abstract class Compte {
private int code;
protected float solde;
private static int nbComptes;
// Constructeurs
// Méthodes

83
Les méthodes abstraites
◼ Une méthode abstraite peut être déclarée à
l’intérieur d’une classe abstraite.
◼ Une méthode abstraite est une méthode qui
n’a pas de définition.
◼ Une méthode abstraite est une méthode qui
doit être redéfinie dans las classes dérivées.
◼ Exemple :
❑ On peut ajouter à la classe Compte une méthode
abstraite nommée afficher() pour indiquer que
tous les comptes doivent redéfinir cette méthode.

84
Les méthodes abstraites
public abstract class Compte {
// Membres

// Méthode abstraite
public abstract void afficher();

public class CompteSimple extends Compte {

// Membres
…
public void afficher(){
[Link]("Solde="+solde+"
Découvert="+decouvert);
}
}
86
Interfaces
◼ Une interface est une sorte de classe abstraite qui ne contient que des méthodes
abstraites.
◼ Dans java une classe hérite d’une seule classe et peut hériter en même temps de
plusieurs interface.
◼ On dit qu’une classe implémente une ou plusieurs interfaces.
◼ Une interface peut hériter de plusieurs interfaces. Exemple d’interface:
public interface Solvable {
public void solver();
public double getSole();
}
◼ Pour indiquer que la classe CompteSimple implémente cette interface on peut
écrire:
public class CompteSimple extends Compte implements Solvable {
private float decouvert;
public void afficher() {
[Link]("Solde="+solde+" Découvert="+decouvert);
}
public double getSole() {
return solde;
}
public void solver() {
[Link]=0;
}} 87
Classe de type final
◼ Une classe de type final est une classe qui ne peut pas être
dérivée.
◼ Autrement dit, on ne peut pas hériter d’une classe final.
◼ La classe CompteSimple peut être déclarée final en écrivant:
public final class CompteSimple extends Compte {
private float decouvert;
public void afficher() {
[Link]("Solde="+solde+"
Découvert="+decouvert);
}
}

88
Variables et méthodes final
◼ Une variable final est une variable dont la valeur ne peut pas
changer. Autrement dit, c’est une constante:
❑ Exemple : final double PI=3.14;

◼ Une méthode final est une méthode qui ne peut pas être
redéfinie dans les classes dérivées.
❑ Exemple : La méthode verser de la classe suivante ne peut pas
être redéfinie dans les classes dérivées car elle est déclarée final
❑ public class Compte {
private int code; protected float solde;
private static int nbComptes;

public final void verser(float mt){

solde+=mt;
}
public void retirer(float mt){
if(mt<solde) solde-=mt;
}
}

89
Membres statiques d’une classe
◼ Les membres (attributs ou méthodes) d’une classe sont des membres
qui appartiennent à la classe et sont partagés par toutes les instances
de cette classe.
◼ Les membres statiques ne sont pas instanciés lors de l’instanciation de
la classe
◼ Les membres statiques sont accessibles en utilisant directement le
nom de la classe qui les contient.
◼ Il n’est donc pas nécessaire de créer une instance d’une classe pour
utiliser les membres statiques.
◼ Les membres statiques sont également accessibles via les instances
de la classe qui les contient.
◼ Exemple d’utilisation :
◼ double d=[Link](9);
❑ Ici nous avons fait appel à la méthode sqrt de la classe Math sans créer
aucune instance. Ceci est possible car la méthode sqrt est statique.
❑ Si cette méthode n’était pas statique, il faut tout d’abord créer un objet de la
classe Math avant de faire appel à cette méthode:
◼ Math m=new Math();
◼ double d=[Link](9);
◼ Les seuls membres d’une classe, qui sont accessibles, sans
instanciation sont les membres statiques.

90
Qui peut le faire (Qui):
◼ private:
❑ L'autorisation private est la plus restrictive. Elle s'applique aux membres
d'une classe (variables, méthodes et classes internes).
❑ Les éléments déclarés private ne sont accessibles que depuis la classe qui
les contient.
❑ Ce type d'autorisation est souvent employé pour les variables qui ne doivent
être modifiées ou lues qu'à l'aide d'un getter ou d'un setter.
◼ public:
❑ Un membre public d’une classe peut être utilisé par n’importe quelle autres
classe.
❑ En UML le membres public sont indiqués par le signe +
◼ protected:
❑ Les membres d'une classe peuvent être déclarés protected.
❑ Dans ce cas, l'accès en est réservé aux méthodes des classes appartenant
◼ au même package
◼ aux classes dérivées de ces classes,
◼ ainsi qu'aux classes appartenant aux mêmes packages que les classes dérivées.
◼ Autorisation par défaut : package
❑ L'autorisation par défaut, que nous appelons package, s'applique aux classes,
interfaces, variables et méthodes.
❑ Les éléments qui disposent de cette autorisation sont accessibles à toutes les
méthodes des classes du même package.

91
Résumé: Héritage
◼ Une classe peut hériter d’une autre classe en utilisant le mot
extends.
◼ Une classe Hérite d’une autre tout ses membres sauf le
constructeur.
◼ Il faut toujours définir le constructeur de la nouvelle classe
dérivée.
◼ Le constructeur de la classe dérivée peut appeler le constructeur
de la classe parente en utilisant le mot super(), avec la liste des
paramètres.
◼ Quand une classe hérite d’une autre classe, elle a le droit de
redéfinir les méthodes héritées.
◼ Dans une méthode redéfinie, on peut appeler la méthode de la
classe parente en écrivant le mot super suivi d’un point et du
nom de la méthode parente. (super.méthode()).
◼ Un constructeur peut appeler un autre constructeur de la même
classe en utilisant le mot this() avec des paramètres du
constructeur.

92
 Résumé: Accessibilté
◼ Pour utiliser une classe il faut connaitre:
❑ Où trouver la classe (package)
❑ Quels sont les droits d’accès à cette classe (Quoi?)
❑ Quelles sont les classes qui ont le droit d’accéder aux membres
de cette classe (Qui?)
◼ Où?
❑ Pour utiliser une classe il faut importer son package en utilisant
l’instruction import
❑ Pour déclarer le package d’appartenance d’une classe on utilise
l’instruction package
❑ La variable d’environnement classpath permet de déclarer les
chemins ou la JVM trouvera les classes d’une application

93
 Résumé: Accessibilté
◼ Quoi?
❑ abstract :
◼ Une classe abstraite est une classe qui ne peut pas être instanciée.
◼ Une méthode abstraite est une méthode qui peut être définie à l’intérieur d’une classe
abstraite. C’est une méthode qui n’a pas de définition. Par conséquent, elle doit être
redéfinie dans les classes dérivées.
◼ Une interface est une sorte de classe abstraite qui ne contient que des méthodes
abstraites.
◼ Dans java une classe hérite toujours d’une seule classe et peut implémenter plusieurs
interfaces.
❑ final:
◼ Une classe final est une classe qui ne peut pas être dérivée.
◼ Une méthode final est une méthode qui ne peut pas être redéfinie dans les classes
dérivées.
◼ Une variable final est une variable don la valeur ne peut pas changer
◼ On utilise final pour deux raisons: une raison de sécurité et une raison d’optimisation
❑ static:
◼ Les membres statiques d’une classe appartiennent à la classe et partagés par toutes ses
objets
◼ Les membres statiques sont accessible en utilisant directement le nom de la classe
◼ Les membres statiques sont accessible sans avoir besoin de créer une instance de la
classe qui les contient
◼ Les membres statiques sont également accessible via les instances de la classe qui les
contient
94
 Résumé: Accessibilté
◼ Qui?
❑ Java dispose de 4 niveaux d’autorisations:
❑ private :
❑ protected:
❑ public:
❑ package (Autorisation par défaut)

95
Travail à faire

◼ Implémenter la classe Compte

◼ Implémenter la classe CompteSimple
◼ Implémenter la classe CompteEpargne
◼ Implémenter la classe ComptePayant
◼ Créer une application pour tester les
différentes classes.

96
[Link]
package metier; // Getters et Setters
public int getCode() {
public abstract class Compte { return code;
private int code; }
public float getSolde() {
protected float solde;
return solde;
private static int nbComptes; }
public static int getNbComptes() {
public Compte(float s){ return nbComptes;
code=++nbComptes; }
[Link]=s; }
}
public void retirer(float mt){
if(mt<solde) solde-=mt;
}
public void verser(float mt){
solde+=mt;
}
public String toString(){
return("Code="+code+"
Solde="+solde);

97
[Link]
package metier; //Getters et Setters
public float getDecouvert() {
public final class CompteSimple return decouvert;
extends Compte { }
private float decouvert; public void setDecouvert(float
decouvert) {
// Constructeurs [Link] = decouvert;
public CompteSimple(float s,float d){ }
super(s); }
[Link]=d;
}
public CompteSimple(){
super();
}
public void retirer(float mt) {
if(solde+decouvert>mt) solde-=mt;
}
public String toString() {
return "Compte Simple
"+[Link]()+"
Solde="+solde;

98
[Link]
package metier; // Getters et Setters
public float getTaux() {
public class CompteEpargne extends return taux;
Compte { }
private float taux; public void setTaux(float taux) {
//Constructeurs [Link] = taux;
}
public CompteEpargne() { }
this(0,6);
}

public CompteEpargne(float
solde,float taux) {
super(solde);
[Link]=taux;
}
public void calculInterets(){
solde=solde*(1+taux/100);
}
public String toString() {
return "Compte Epargne
"+[Link]()+" Taux="+taux;
}

99
[Link]
package metier;

public class ComptePayant

extends Compte {
// Constructeur
public ComptePayant(float
solde) {
super(solde);
}
public void verser(float mt) {
[Link](mt);
[Link](mt*5/100);
}
public void retirer(float mt) {
[Link](mt);
[Link](mt*5/100);
}
public String toString() {
return [Link]();
}
}

100
 Application [Link]
package test; // Test de ComptePayant
ComptePayant c3=new
import metier.*; ComptePayant(5000);
public class TestCompte { [Link](c3);
public static void main(String[] args) { [Link](6000);
// Tester la classe Compte Simple [Link](4000);
CompteSimple c1=new CompteSimple(8000,4000); [Link](c3);
[Link]([Link]()); }
[Link](3000); }
[Link](5000);
[Link](5500);
[Link]([Link]());
// Tester la classe Compte Epargne
CompteEpargne c2=new CompteEpargne(50000,5);
[Link]([Link]());
[Link](30000);
[Link](6000);
[Link]();
[Link]([Link]());
[Link](6);
[Link]();
[Link](c2);

101
Polymorphisme

102
Polymorphisme

◼ Le polymorphisme offre aux objets la

possibilité d ’appartenir à plusieurs catégories
à la fois.
◼ En effet, nous avons certainement tous
appris à l'école qu'il était impossible
d'additionner des pommes et des oranges
◼ Mais, on peut écrire l ’expression suivante:
3 pommes + 5 oranges = 8 fruits

103
Polymorphisme

◼ Le sur-casting des objets:

◼ Une façon de décrire l'exemple consistant à additionner des
pommes et des oranges serait d'imaginer que nous disons
pommes et oranges mais que nous manipulons en fait des fruits.
Nous pourrions écrire alors la formule correcte :
3 (fruits) pommes
+ 5 (fruits) oranges

= 8 fruits
◼ Cette façon de voir les choses implique que les pommes et les
oranges soient "transformés" en fruits préalablement à
l'établissement du problème. Cette transformation est appelée
sur-casting

104
Instanciation et héritage

◼ Considérons l’exemple suivant:

Fruit
poids:int
Fruit()
affiche():void

Pomme Orange

Pomme(int p) Orange(int p)
affiche():void affiche():void
affichePoids() affichePoids()

105
 Instanciation et héritage
public abstract class Fruit{ public class Orange extends Fruit{
int poids; public Orange(int p){
public Fruit(){ poids=p;
[Link]("Création d'un [Link]("création d'une
fruit"); Orange de "+ poids+" grammes ");
} }
public void affiche(){ public void affiche(){
[Link]("c'est un fruit"); [Link]("C'est une
} Orange");
} }
public void affichePoids(){
public class Pomme extends Fruit{ [Link]("le poids de la
public Pomme(int p){ Orange est:"+poids+" grammes");
poids=p; }
[Link]("création d'une pomme }
de "+ poids+" grammes ");
}
public void affiche(){ public class Polymorphisme{
[Link]("C'est une pomme"); public static void main(String[] args){
} Pomme p=new Pomme(72);
public void affichePoids(){ Orange o=new Orange(80);
[Link]("le poids de la pomme }
est:"+poids+" grammes"); }
}
}
106
Instanciation et héritage
◼ Le résultat affiché par le programme est:
Création d'un fruit
Création d'une pomme de 72 grammes
Création d'un fruit
création d'une orange de 80 grammes

◼ Nous constatons qu'avant de créer une Pomme,

le programme crée un Fruit, comme le montre
l'exécution du constructeur de cette classe. La
même chose se passe lorsque nous créons une
Orange

107
Sur-casting des objets

◼ Considérons l’exemple suivant:

public class Polymorphisme2{
public static void main(String[] args){
// Sur-casting implicite
Fruit f1=new Orange(40);
// Sur-casting explicite
Fruit f2=(Fruit)new Pomme(60);
// Sur-casting implicite
f2=new Orange(40);
}
}

108
Sur-casting des objets
◼ Un objet de type Pomme peut être affecté à un handle de type
fruit sans aucun problème :
❑ Fruit f1;

❑ f1=new Pomme(60);

◼ Dans ce cas l’objet Pomme est converti automatiquement en

Fruit.
◼ On dit que l’objet Pomme est sur-casté en Fruit.
◼ Dans java, le sur-casting peut se faire implicitement.
◼ Toutefois, on peut faire le sur-casting explicitement sans qu’il soit
nécessaire.
◼ La casting explicit se fait en précisant la classe vers laquelle on
convertit l’objet entre parenthèse. Exemple :
❑ f2=(Fruit)new Orange(40);

109
 Sous-Casting des objets

◼ Considérons l’exemple suivant:

public class Polymorphisme3{
public static void main(String[] args){
Fruit f1;
Fruit f2; ◼ Erreur de compilation:
f1=new Pomme(60); [Link]: cannot resolve symbol
f2=new Orange(40); symbol : method affichePoids ()
location: class Fruit
[Link](); [Link]();
((Pomme)f1).affichePoids(); ^
} error

◼ Solution : Sous-casting explicit

110
Sous-casting des objets
◼ Ce message indique que l’objet f1 qui est de type Fruit ne possède pas
la méthode affichePoids().
◼ Cela est tout à fait vrai car cette méthode est définie dans les classes
Pomme et Oranges et non dans la classe Fruit.
◼ En fait, même si le handle f1 pointe un objet Pomme, le compilateur ne
tient pas en considération cette affectation, et pour lui f1 est un Fruit.
◼ Il faudra donc convertir explicitement l’objet f1 qui de type Fruit en
Pomme.
◼ Cette conversion s’appelle Sous-casting qui indique la conversion d’un
objet d’une classe vers un autre objet d’une classe dérivée.
◼ Dans ce cas de figure, le sous-casting doit se faire explicitement.
◼ L’erreur de compilation peut être évité en écrivant la syntaxe suivante :
❑ ((Pomme)f1).affichePoids();
◼ Cette instruction indique que l’objet f1 , de type Fruit, est converti en
Pomme, ensuite la méthode affichePoids() de l’objet Pomme est appelé
ce qui est correcte.

111
Late Binding
◼ Dans la plupart des langages, lorsque le compilateur rencontre un appel de
méthode, il doit être à même de savoir exactement de quelle méthode il s'agit.
◼ Le lien entre l'appel et la méthode est alors établi au moment de la compilation.
Cette technique est appelée early binding, que l'on pourrait traduire par liaison
précoce.
◼ Java utilise cette technique pour les appels de méthodes déclarées final.
◼ Elle a l'avantage de permettre certaines optimisations.
◼ En revanche, pour les méthodes qui ne sont pas final, Java utilise la technique
du late binding (liaison tardive).
◼ Dans ce cas, le compilateur n'établit le lien entre l'appel et la méthode qu'au
moment de l'exécution du programme.
◼ Ce lien est établi avec la version la plus spécifique de la méthode.
◼ Dans notre cas, nous la méthode affiche() possède 3 versions définies dans les
classes Fruit, Pomme et Orange.
◼ Grâce au late binding, java est capable de déterminer, au moment de l’exécution,
quelle version de méthode qui sera appelée ce que nous pouvons vérifier par le
programme suivant :

112
Late Binding
public class Polymorphisme4{
public static void main(String[] args){
Fruit f1;
Fruit f2;
f1=new Pomme(60);
f2=new Orange(40);
[Link]();//((Pomme)f1).affiche();
[Link]();
}
}
L’exécution de ce programme donne :
Création d'un fruit
Création d'une pomme de 60 grammes
Création d'un fruit
Création d'une orange de 40 grammes
C'est une pomme
C'est une Orange

113
Polymorphisme

Pour résumer, un objet est une instance de :

◼ sa classe,
◼ toutes les classes parentes de sa classe,
◼ toutes les interfaces qu'il implémente,
◼ toutes les interfaces parentes des interfaces qu'il
implémente,
◼ toutes les interfaces qu'implémentent les classes parentes de
sa classe,
◼ toutes les interfaces parentes des précédentes.

114
Tableaux et Collections

115
 Tableaux de primitives liste
5 0
12 1
23 2
3
4
5
◼ Tableaux de primitives: 6
◼ Déclaration : 7
8
❑ Exemple : Tableau de nombres entiers 9
◼ int[] liste; 10
❑ liste est un handle destiné à pointer vers un tableau d’entier
◼ Création du tableau
❑ liste = new int[11];

◼ Manipulation des éléments du tableau:

❑ liste[0]=5; liste[1]=12; liste[3]=23;

❑ for(int i=0;i<[Link];i++){

❑ [Link](liste[i]);
❑ }

116
 lesFruits

Tableaux d’objets 0
◼ Déclaration : :Pomme 1
❑ Exemple : Tableau d’objets Fruit poids=60 2
❑ Fruit[] lesFruits; affiche() 3
◼ Création du tableau affichePoids() 4
❑ lesFruits = new Fruit[5];
:Orange
◼ Création des objets:
❑ lesFruits[0]=new Pomme(60); poids=60

❑ lesFruits[1]=new Orange(100); affiche()

❑ lesFruits[2]=new Pomme(55); affichePoids()

◼ Manipulation des objets:

:Pomme
for(int i=0;i<[Link];i++){
poids=60
lesFruits[i].affiche();
if(lesFruits[i] instanceOf Pomme) affiche()

((Pomme)lesFruits[i]).affichePoids(); affichePoids()

else
((Orange)lesFruits[i]).affichePoids();
}
◼ Un tableau d’objets est un tableau de handles
117
Collections
◼ Une collection est un tableau dynamique d’objets de type Object.
◼ Une collection fournit un ensemble de méthodes qui permettent:
❑ D’ajouter un nouveau objet dans le tableau
❑ Supprimer un objet du tableau
❑ Rechercher des objets selon des critères
❑ Trier le tableau d’objets
❑ Contrôler les objets du tableau
❑ Etc…
◼ Dans un problème, les tableaux peuvent être utilisés quand la
dimension du tableau est fixe.
◼ Dans le cas contraire, il faut utiliser les collections
◼ Java fournit plusieurs types de colections:
❑ ArrayList
❑ Vector
❑ Iterator
❑ HashMap
❑ Etc…
◼ Dans cette partie du cours, nous allons présenter uniquement
comment utiliser les collections ArrayList, Vector, Iterator et HashMap
◼ Vous aurez l’occasion de découvrir les autres collections dans les
prochains cours
118
Collection ArrayList
◼ ArrayList est une classe du package [Link], qui implémente l’interface List.
◼ Déclaration d’une collection de type List qui devrait stocker des objets de type
Fruit:
❑ List<Fruit> fruits;
◼ Création de la liste:
❑ fruits=new ArrayList<Fruit>();
◼ Ajouter deux objets de type Fruit à la liste:
❑ [Link](new Pomme(30));
❑ [Link](new Orange(25));
◼ Faire appel à la méthode affiche() de tous les objets de la liste:
❑ En utilisant la boucle classique for
for(int i=0;i<[Link]();i++){
[Link](i).affiche();
}
❑ En utilisant la boucle for each
for(Fruit f:fruits)
[Link]();
◼ Supprimer le deuxième Objet de la liste
❑ [Link](1);

119
 Exemple d’utilisation de ArrayList
import [Link];import [Link];
public class App1 {
public static void main(String[] args) {
// Déclaration d’une liste de type Fruit
List<Fruit> fruits;
// Création de la liste
fruits=new ArrayList<Fruit>();
// Ajout de 3 objets Pomme, Orange et Pomme à la liste
[Link](new Pomme(30));
[Link](new Orange(25));
[Link](new Pomme(60));
// Parcourir tous les objets
for(int i=0;i<[Link]();i++){
// Faire appel à la méthode affiche() de chaque Fruit de la
liste
[Link](i).affiche();
}
// Une autre manière plus simple pour parcourir une liste
for(Fruit f:fruits) // Pour chaque Fruit de la liste
[Link](); // Faire appel à la méthode affiche() du Fruit f
}
} 120
Collection Vector
◼ Vecor est une classe du package [Link] qui fonctionne comme ArrayList
◼ Déclaration d’un Vecteur qui devrait stocker des objets de type Fruit:
❑ Vector<Fruit> fruits;
◼ Création de la liste:
❑ fruits=new Vector<Fruit>();
◼ Ajouter deux objets de type Fruit à la liste:
❑ [Link](new Pomme(30));
❑ [Link](new Orange(25));
◼ Faire appel à la méthode affiche() de tous les objets de la liste:
❑ En utilisant la boucle classique for
for(int i=0;i<[Link]();i++){
[Link](i).affiche();
}
❑ En utilisant la boucle for each
for(Fruit f:fruits)
[Link]();
◼ Supprimer le deuxième Objet de la liste
❑ [Link](1);

121
 Exemple d’utilisation de Vector
import [Link];
public class App2 {
public static void main(String[] args) {
// Déclaration d’un vecteur de type Fruit
Vector<Fruit> fruits;
// Création du vecteur
fruits=new Vector<Fruit>();
// Ajout de 3 objets Pomme, Orange et Pomme au vecteur
[Link](new Pomme(30));
[Link](new Orange(25));
[Link](new Pomme(60));
// Parcourir tous les objets
for(int i=0;i<[Link]();i++){
// Faire appel à la méthode affiche() de chaque Fruit
[Link](i).affiche();
}
// Une autre manière plus simple pour parcourir un vecteur
for(Fruit f:fruits) // Pour chaque Fruit du veceur
[Link](); // Faire appel à la méthode affiche() du Fruit f
}
}
122
 Collection de type Iterator
◼ La collection de type Iterator du package [Link] est souvent
utilisée pour afficher les objets d’une autre collection
◼ En effet il est possible d’obtenir un iterator à partir de chaque
collection.
◼ Exemple :
❑ Création d’un vecteur de Fruit.
Vector<Fruit> fruits=new Vector<Fruit>();
❑ Ajouter des fruits aux vecteur
[Link](new Pomme(30));
[Link](new Orange(25));
[Link](new Pomme(60));
❑ Création d’un Iterator à partir de ce vecteur
Iterator<Fruit> it=[Link]();
❑ Parcourir l’Iterator:
while([Link]()){
Fruit f=[Link]();
[Link]();
}
◼ Notez bien que, après avoir parcouru un iterator, il devient vide
123
 Collection de type HashMap
◼ La collection HashMap est une classe qui implémente l’interface Map. Cette
collection permet de créer un tableau dynamique d’objet de type Object qui
sont identifiés par une clé.
◼ Déclaration et création d’une collection de type HashMap qui contient des
fruits identifiés par une clé de type String :
❑ Map<String, Fruit> fruits=new HashMap<String, Fruit>();
◼ Ajouter deux objets de type Fruit à la colelction fruits
:Pomme
❑ [Link]("p1", new Pomme(40)); key value
❑ [Link]("o1", new Orange(60)); p1
o1
◼ Récupérer un objet ayant pour clé "p1« :Orange
❑ Fruit f=[Link]("p1");
❑ [Link]();
◼ Parcourir toute la collection:
Iterator<String> it=[Link]().iterator();
while([Link]()){
String key=[Link]();
Fruit ff=[Link](key);
[Link](key);
[Link]();}
124
170