Vous êtes sur la page 1sur 136

Zarrouk Elyes

COURS
PROGRAMMATION ORIENTÉE
OBJET
1 Zarrouk Elyes
Ecole Nationale d’Ingénieurs de Sousse
PLAN DU COURS
 Introduction à la POO
 Types et instructions de base du java

Zarrouk Elyes
 Objets et classes

 Les packages et l’encapsulation

 Les tableaux et les vecteurs dynamiques

 L’héritage en java

 Le polymorphisme en java

 Les classes abstraites et les interfaces

2
RÉFÉRENCES
 Claude Delanoy « Programmer en Java » 5 ème édition
Java 5 et 6

Zarrouk Elyes
 H. Mounier « Structures de données Notions en Génie
Logiciel et programmation Orientée Objet: Support de
cours Java »
 En ligne:
http://jmdoudoux.developpez.com/cours/devel
oppons/java/
http://www.infres.enst.fr/~hudry/coursJava/
http://www.ethnoinformatique.fr/course/view.
php?id=54
3
INTRODUCTION GÉNÉRALE À LA POO
~GÉNÉRALITÉS
 Problèmes du logiciel:
 Taille

Zarrouk Elyes
 Coût : développement et maintenance
 Fiabilité
 Solutions :
 Modularité
 Réutiliser le logiciel
 Certification

4
INTRODUCTION GÉNÉRALE À LA POO
~HISTOIRE
 Années 60:
 Programmation des simulations par événements discrets.
 Années 70:

Zarrouk Elyes
 Développement par Xérox du premier systéme Fenêtres Icônes et souris.
 Développement par Apple des premiers Mac

 Années 80:
 Développement des ordinateurs personels.
 Intérêt pour les interfaces graphiques
 Apparition du Eiffel, C++ et Object Pascal

 Années 90:
 Maturité des langages Orientés Objet
 Standardisation du C++
5
 Apparition du JAVA ou du Python
INTRODUCTION GÉNÉRALE À LA POO
~HISTOIRE
 Programmation machine: résolution des problèmes en terme
des éléments du processeur (registre, adresse..)
(assembleur...)

Zarrouk Elyes
 Programmation classique: utilisation des langages ‘haut
niveau’: Résolution des problèmes en termes de calcul
numérique et structuration des données simples (Pascal,
c…)
 Programmation orientée objet: résolution des problèmes
complexes en exprimant la vision du concepteur (C++,
Smalltalk, Java…)

6
INTRODUCTION GÉNÉRALE À LA POO
~HISTOIRE

Zarrouk Elyes
7
INTRODUCTION GÉNÉRALE À LA POO
~JAVA?
Selon le concept « write once, run everywhere »,le
concepteur Sun Microsystems Java devrait être un
langage multi-platforme qui permettait de décrire une

Zarrouk Elyes
fois pour toutes les applications capables de fonctionner
dans tous les environnemments.
Antoine Mirecourt
Pierre-Yves Saumont

8
INTRODUCTION GÉNÉRALE À LA POO
~JAVA?
 Langage de programmation orientée objet très récente
(1995).

Zarrouk Elyes
 Langage utilisé dans plusieurs domaines:
 Réseaux/Internet
 Applications Client/Serveurs …

 Inspirée du C++ et Smaltalk


 Versions gratuites disponibles sur Internet

9
INTRODUCTION GÉNÉRALE À LA POO
~JAVA?
 Deux types d'applications…
 Application "classique"…

Zarrouk Elyes
 S'exécute sur la machine en local
 Grâce à la machine virtuelle

 Applet
 S'exécute en réseau
 Grâce à la machine virtuelle du navigateur

10
INTRODUCTION GÉNÉRALE À LA POO
~CARACTÉRISTIQUES

 Simple  Perfomant

Zarrouk Elyes
 Orientée objets  Sécurisé
 Robuste  Multi-threads
 Portable  Distribué

11
INTRODUCTION GÉNÉRALE À LA POO
~CARACTÉRISTIQUES: SIMPLICITÉ

 Pas de Pointeurs

Zarrouk Elyes
Pas d’héritage Multiple
 Développements 30 à 35% plus rapides
 Supporte les applications distribués

12
INTRODUCTION GÉNÉRALE À LA POO
~CARACTÉRISTIQUES: ROBUSTESSE

 Syntaxe de C++, gestion dynamique de la mémoire de

Zarrouk Elyes
SmallTalk
 Langage Objet pur, contrairement à C++
 Tout est classe sauf les types primitifs (int, float, double,
etc.)
 Toutes les classes dérivent de Java.lang.Objects

13
INTRODUCTION GÉNÉRALE À LA POO
~CARACTÉRISTIQUES: ROBUSTESSE

 La gestion de la mémoire n’est plus à la charge du

Zarrouk Elyes
développeur
 Un débordement d’index dans un tableau provoque une
erreur de compilation
 Compilateur très strict, en particulier car :
– Contrôle de typage fort (pertes de précisions interdites)
– Vérifications que les erreurs identifiées (exceptions) sont traitées
par le développeur

14
INTRODUCTION GÉNÉRALE À LA POO
~CARACTÉRISTIQUES: PORTABILITÉ

 Le compilateur Java génère un code assembleur virtuel : le


byte code

Zarrouk Elyes
 Le byte code est exécute par un logiciel : la Machine
Virtuelle
 La Java Virtuel Machine (JVM) est présente sur UNIX,
MAC, Netscape, IE,…
 La taille des types primitifs est indépendante de la plate-
forme
 Java supporte un code source écrit en Unicode (représenté
sur 32 bits)
15
INTRODUCTION GÉNÉRALE À LA POO
~CARACTÉRISTIQUES: SÉCURITÉ

 Le compilateur interdit toute manipulation directe de la

Zarrouk Elyes
mémoire
 Trois couches de sécurité:
– Verifier: vérifie le byte code.
– Class Loader : responsable du chargement de
classes.
– Security Manager : accès au ressources

16
INTRODUCTION GÉNÉRALE À LA POO
~CARACTÉRISTIQUES

Java C++

Zarrouk Elyes
 Pas de structures  Pas d’héritage multiple de
 Pas de types énumérés classes
 Pas de typedef  Pas de surcharge d’opérateurs
 Pas de variables ni de  Pas de passage par copie pour
fonctions en dehors des les objets
classes  Pas de pointeurs, seulement des
références

17
INTRODUCTION GÉNÉRALE À LA POO
~PROGRAMMER EN JAVA!
 Série d’énoncés organisés en bloc
 Les énoncés définissent ces données et des opérations sur ces

Zarrouk Elyes
données
 la compilation du programme fournit un code indépendant de
la machine sur laquelle il s’exécute.
 Le compilateur Java génère du byte-code .(Le byte-code
constitue les instructions pour la machine virtuelle JVM)
 La Java Virtual Machine existe par défaut sur de nombreuses
plateformes (Unix, Win32, Mac, OS/2, Netscape, IE...) peut
être aisément installée.
18
INTRODUCTION GÉNÉRALE À LA POO
~PROGRAMMER EN JAVA!

Fichier texte (extension .java)

Zarrouk Elyes
Fichier compilé en pseudo-code (bytecode)
Indépendant de la machine (extension .class)

Machine virtuelle sur Machine virtuelle sur Machine virtuelle sur


Système UNIX Système MAC Système WINDOWS

19
INTRODUCTION GÉNÉRALE À LA POO
~PROGRAMMER EN JAVA! JVM
 Java Rin-time Environment (JRE)
 Sun(Windows, Linux,Solaris)

Zarrouk Elyes
 IBM(AIX, Linux…)
 Apple(MAC)

 Java Development Kit (JDK)


 Compilateur(java)
 Interpréteur(javac)
 Générateur de documentation(javadoc)

20
INTRODUCTION GÉNÉRALE À LA POO
~PROGRAMMER EN JAVA! JDK
 javac le compilateur java
 java un interpréteur d'applications

Zarrouk Elyes
 appletviewer un interpréteur d'applets
 jdb un debogueur
 javap un décompilateur
 javadoc un générateur de documentation
 jar un compresseur de classes java

21
INTRODUCTION GÉNÉRALE À LA POO
~PROGRAMMER EN JAVA! JDK
• Javac :
– compile les fichiers .java

Zarrouk Elyes
– produit autant de fichiers .class qu’il y a de classes dans
le fichiers .java
• Java :
– Prend en paramètre le nom d’une classe
– Cherche un fichier .class correspondant à ce nom
– Charge la classe correspondante et appelle la méthode
main de cette classe

22
INTRODUCTION GÉNÉRALE À LA POO
~PROGRAMMER EN JAVA! EXEMPLE

Fichier HelloWorld.java
Public class HelloWorld {

Zarrouk Elyes
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
Compilation
javac HelloWorld.java
Exécution
java HelloWorld
Hello World !
23
INTRODUCTION GÉNÉRALE À LA POO
~PROGRAMMER EN JAVA! LES OUTILS?

 Environnements de développement :
– Kawa, Visual Age, Café, Jbuilder, Visual J++,Netbeans,

Zarrouk Elyes
Eclipse,…
 Browsers :
– Sun HotJava , Netscape , Internet Explorer
 Convertisseur :
– c2j, j2c

24
Zarrouk Elyes
TYPES ET INSTRUCTIONS DE
BASE DU LANGAGE JAVA
25 Zarrouk Elyes
Ecole Nationale d’Ingénieurs de Sousse
TYPES ET INSTRUCTIONS DE BASE
DU JAVA
~INTRODUCTION
 Un programme en langage JAVA consiste en une série
d'énoncés (statements) organisés en blocs. Ces énoncés
définissent des données et des opérations sur ces données

Zarrouk Elyes
 La fin de chaque énoncé est marquée par un ;. Ce
caractère indique à l'interpréteur JAVA que l'énoncé est
complet, qu'il doit être exécuté avant de passer à l'énoncé
suivant.
 L'ordre dans lequel l'interpréteur JAVA exécute les
énoncés s'appelle le flôt d'exécution ou flôt de contrôle.

26
TYPES ET INSTRUCTIONS DE BASE DU
JAVA
~TYPES PRIMITIFS
type désignation domaine opérations

-128 à 127 
byte entiers sur 8 bits 
-32768 à  32767 
short entiers sur 16 bits  unaire :  +, - 

Zarrouk Elyes
entiers -2147483648 à 2147483647 
int entiers sur 32 bits  binaire :  +, -, *, /  %
-9223372036854775808 à
long entiers sur 64 bits
9223372036854775807

+- 3.40282346638528860e+38  
float réels simple précision
+- 1.40129846432481707e-45
(32 bits)  unaire :  +, - 
réels
double réels double précision binaire :  +, -, *, / 
+- 1.79769313486231570e+308 
(64bits)
+- 4.94065645841246544e-324

codage Unicode (valeurs entières


caractère char  
sur 16 bits)

&& et logique  27
booléen boolean true false || ou logique 
! négation
TYPES ET INSTRUCTIONS DE BASE DU
JAVA
~OPÉRATIONS LOGIQUES

Zarrouk Elyes
strictement supérieur strictement inférieur
égal différent
supérieur ou égal inférieur ou égal

== != > >= < <=

28
JAVA
~ ÉNONCÉS ÉLÉMENTAIRES:
DÉCLARATION
 syntaxe:  
déclaration: 
               type identificateur

Zarrouk Elyes
 exemples:
byte age;
boolean jeune;
float poids;
 Une variable est accessible (visible) depuis
l'endroit où elle est déclarée jusqu'à la fin du 
bloc où sa déclaration a été effectuée.
29
TYPES ET INSTRUCTIONS DE BASE DU JAVA
~ ÉNONCÉS ÉLÉMENTAIRES: AFFECTATION
 syntaxe: 
affectation: 
                   lvalue = expression 

Zarrouk Elyes
 lvalue est une expression qui doit délivrer une variable (par exemple
un identificateur de variable, élément de tableau...., mais pas une
constante)
 exemples:
age = 10;
jeune = true;
poids = 71.5f;
 Attention en JAVA comme en C, l'affectation est un opérateur.
L'affectation peut donc être utilisée comme une expression dont la
valeur est la valeur affectée à la variable. 30
 i = j = 10;
TYPES ET INSTRUCTIONS DE BASE DU JAVA
~ FLOTS DE CONTRÔLE: BLOC
D’INSTRUCTIONS

 Permet de grouper un ensemble d'instructions en lui donnant la forme

Zarrouk Elyes
syntaxique d'une seule instruction 
 syntaxe: 
instruction composée: 
                  { 
                    sequence d'enoncés 
                  } 
 
 exemples:

int k;
{
    int i = 1; 
    int j = 12;
    j = i+1; 
    k = 2 * j - i; 31
}
TYPES ET INSTRUCTIONS DE BASE DU JAVA
~ FLOTS DE CONTRÔLE: INST.
CONDITIONNELLE

Instruction if:
 syntaxe: 
 if ( expression booléenne ) instruction1

Zarrouk Elyes
 ou bien

 if ( expression booléenne )  
      instruction1 
else 
     instruction2
 sémantique : expression booléeene est évaluée. Si sa valeur vaut true,  instruction1 est exécutée,
sinon instruction2 si elle existe est exécutée. 
 
 exemples: 
if (i==j) 
{
   j = j -1; 
   i = 2 * j; 

else  32
   i = 1;
TYPES ET INSTRUCTIONS DE BASE DU JAVA
~ FLOTS DE CONTRÔLE: INST.
CONDITIONNELLE
Instruction switch
 Syntaxe
switch (<expression_entière>) {

Zarrouk Elyes
case valeur_1: ......;
break;
case valeur_2: ......;
......;
case valeur-n: ......;
......;
break;
default: ......;
......;}

La présence de l'instruction break permet de sortir du switch si une


languette correspond à la valeur préférée.
33
TYPES ET INSTRUCTIONS DE BASE DU JAVA
~ FLOTS DE CONTRÔLE: INST.
CONDITIONNELLE
Instruction switch
 Le choix multiple

Zarrouk Elyes
 branchement lorsque l'expression entière est égale à

une des valeurs des case


 branchement à default si aucune valeur trouvée

 passe en séquence jusqu'au premier break

ou fin du switch

34
TYPES ET INSTRUCTIONS DE BASE DU JAVA
~ FLOTS DE CONTRÔLE: INST. CONDITIONNELLE
Exemple
int note ; //On imagine que la note maximale est 20
..

Zarrouk Elyes
//(saisir la valeur de la note)
..
switch (note)
{
case 0:
System.out.println("Ouch !"); break;
case 10:
System.out.println("Vous avez juste la moyenne."); break;
case 20:
System.out.println("Parfait !"); break;
default: 35
System.out.println("Il faut davantage travailler.");}
TYPES ET INSTRUCTIONS DE BASE DU JAVA
~ FLOTS DE CONTRÔLE
Instruction break
 L'instruction break permet de sortir

Zarrouk Elyes
 d'un switch
 d'un for
 d'un while
 d'un do

for(;;) {
if (EVENEMENT) break;
/* si EVENEMENT devient VRAI on sort */
}
36
TYPES ET INSTRUCTIONS DE BASE DU JAVA
~ FLOTS DE CONTRÔLE
Instruction continue
 L'instruction continue force le branchement en fin de
boucle d'une répétitive

Zarrouk Elyes
 la condition de passage est retestée
 évite l'écriture d'un sinon

while (i<10) {
.......;
.......;
if (n<0) continue;
.......; /* traitement si n >= 0 */
} 37
TYPES ET INSTRUCTIONS DE BASE DU JAVA
~ FLOTS DE CONTRÔLE: INST. CONDITIONNELLE
Exemple
int note ; //On imagine que la note maximale est 20
..

Zarrouk Elyes
//(saisir la valeur de la note)
..
switch (note)
{
case 0:
System.out.println("Ouch !"); break;
case 10:
System.out.println("Vous avez juste la moyenne."); break;
case 20:
System.out.println("Parfait !"); break;
default: 38
System.out.println("Il faut davantage travailler.");}
TYPES ET INSTRUCTIONS DE BASE DU JAVA
~ FLOTS DE CONTRÔLE: INST. ITÉRATIVE

Instruction while:
 syntaxe: 

Zarrouk Elyes
 while ( expression booléenne ) 
       instruction 
 sémantique :  
1) expression booléeene est évaluée. Si sa valeur vaut true, l'étape 2 est réalisée sinon
l'exécution de l'instruction while est terminée 
2) instruction est exécutée, puis l'étape 1) est renouvelée.
 exemple: 
int i = 0; 
int somme = 0; 
while (i <= 10) 

   somme += i; 
   i++; 
}  39
System.out.println("Somme des 10 premiers entiers" + somme);
TYPES ET INSTRUCTIONS DE BASE DU JAVA
~ FLOTS DE CONTRÔLE: INST. ITÉRATIVE
 Instruction do while :
 syntaxe: 
 do 

Zarrouk Elyes
     instruction 
while ( expression booléenne ) ; 
  
 sémantique : 
 1) instruction est exécutée 
2) expression booléeene est évaluée. Si sa valeur  vaut true, l'étape 1 est renouvelée sinon
l'exécution de l'instruction do while est terminée
 exemple: 
int i = 0; 
int somme = 0; 
do { 
   somme += i; 
   i++; } 
while (i <= 10);  40
System.out.println("Somme des 10 premiers entiers" + somme);
TYPES ET INSTRUCTIONS DE BASE DU JAVA
~ FLOTS DE CONTRÔLE: INST. RÉPÉTITIVE

 Instruction for (boucle pour)


 syntaxe: 

Zarrouk Elyes
 for (expression1 ; expression2; expression3) 
     instruction 
  
sémantique : 
 1) expression1 est évaluée (en général elle initialise un itérateur
(variable de comptage du nombre d'itérations), cf. l'affectation qui est
une expression). Cette expression n'est évaluée qu'une seule fois. 
2) expression 2 est évaluée,  si sa valeur vaut true le contrôle passe à
l'étape 3 sinon l'exécution de l'instruction for est terminée 
3) instruction est exécutée, puis expression3 est évaluée (en général elle
modifie l'itérateur) puis l'étape 1 est renouvellée. expression3 est ainsi 41
évaluée après chaque itération.
TYPES ET INSTRUCTIONS DE BASE DU
JAVA
~ AFFICHAGE SUR LE CONSOLE

 System.out.print (chaine de caractères à afficher) affiche la

Zarrouk Elyes
chaîne sur la console
 
 System.out.println (chaine de caractères à afficher) affiche la
chaîne sur la console avec un retour à la ligne

42
TYPES ET INSTRUCTIONS DE BASE DU
JAVA
~ AFFICHAGE SUR LE CONSOLE
 la chaîne de caractères qui définit le texte à afficher peut
être :

Zarrouk Elyes
 une constante chaîne de caractères (String) .
 System.out.println("coucou");  // affiche le texte coucou
 une expression de type String
 System.out.println(age);  // affiche la valeur de la variable age
 une combinaison (concaténation) de constantes et d'expressions
de type String. La concaténation est exprimée à l'aide de
l'opérateur +
 System.out.println("L'age de la personne est " + age + " , son poids " +
poids + " kg");
produit sur la console la chaîne : L'age de la personne est 12 , son poids :
33.33333333333336 kg
43
TYPES ET INSTRUCTIONS DE BASE DU JAVA
~ EXERCICE
Soit le programme suivant :
public class Exercice
{ public static void main(String[] args)

Zarrouk Elyes
{ int i, n, som ;
som = 0 ;
for (i=0 ; i<4 ; i++)
{ System.out.println ("donnez un entier ") ;
n = Clavier.lireInt() ;//on suppose que Clavier.lireInt() permet de saisir un entier à partir
du clavier
som += n ;
}
System.out.println ("Somme : " + som) ;}
}
Écrire un programme réalisant la même chose en employant à la place de l’instruction for :
1. une instruction while, 44
2. une instruction do... while.
TYPES ET INSTRUCTIONS DE BASE DU JAVA
~ CORRECTION
Avec une instruction while :
public class Exercice
{ public static void main(String[] args)

Zarrouk Elyes
{ int i, n, som ;
som = 0 ;
i=0;
while (i<4)
{ System.out.println ("donnez un entier ") ;
n = Clavier.lireInt() ;
som += n ;
i++ ;
}
System.out.println ("Somme : " + som) ; 45
}}
Zarrouk Elyes
OBJETS ET CLASSES
46 Zarrouk Elyes
Ecole Nationale d’Ingénieurs de Sousse
OBJETS ET CLASSES
~CONCEPTS DE BASE
 "Classe " signifie une catégorie de choses
 Une classe est constituée de descriptions de :

Zarrouk Elyes
 données : que l’on nomme attributs.
 procédures : que l’on nomme méthodes
 Une classe est un modèle de définitions pour des objets
 ayant même structure (même ensemble d'attributs),
 ayant même comportement (mêmes opérations, méthodes),
 ayant une sémantique commune.
 le nom d’une classe peut être utilisé en java comme le type
d’une variable locale ou d’un attribut et aussi comme le type de
retour d’une fonction (méthode) 47
OBJETS ET CLASSES
~CONCEPTS DE BASE
 " Objet " correspond à un élément particulier
appartenant à une classe (une instance)

Zarrouk Elyes
 Les objets sont des représentations dynamiques
(instanciation), « vivantes » du modèle défini pour eux
au travers de la classe.
 Une classe permet d’instancier (créer)plusieurs objets
 Chaque objet est instance d’une (seule) classe

48
OBJETS ET CLASSES
~CONCEPTS DE BASE
 Objet = informations + comportements
 Informations = caractéristiques de l ’objet

Zarrouk Elyes
attributs, variables d’instance, données
 Comportements = traitements applicables à l’objet
méthodes, opérations

Propriétés communes  Classe

Objet, instance = élément d’une classe


Classe  Instance = INSTANCIATION
49
OBJETS ET CLASSES
~CONCEPTS DE BASE Nom de la classe
Point
x: double
Y:double

Zarrouk Elyes
Attributs
translater ( dx: double, dy: double)
distance () :double
méthodes

B
Point O =new Point (0,0);
Point A =new Point (4,0);
Point B =new Point (4,4);
.
.
.
50
O A
OBJETS ET CLASSES
~STRUCTURE GÉNÉRALE D’UNE CLASSE
modificateur class nom_classe
{

Zarrouk Elyes
modificateur type attribut1;
modificateur type attribut2;

modificateur type attributN;
modificateur Type_de_retour nom_méthode1 (paramètres)
{ // instructions}

modificateur Type_de_retour nom_méthodeM (paramètres)
{ // instructions}
51
}
OBJETS ET CLASSES
~STRUCTURE GÉNÉRALE D’UNE CLASSE
class Interrupteur { // Interrupteur est le nom de la classe
boolean open; // Ceci est un attribut

Zarrouk Elyes
void setState (boolean newstate)
{ // Ceci est une méthode
open = newstate;
}
void printState()
{ // Ceci est une deuxième méthode
if (open) System.out.println (" l’interrupteur est ouvert");
else System.out.println ("l’interrupteur est fermé");
} 52
}
OBJETS ET CLASSES
~L'OPÉRATEUR THIS

This permet d'invoquer


 l'objet lui-même

Zarrouk Elyes
class Rectangle
{
double larg, long ;
Rectangle (double l, double L) {this.larg=l;this.long=L;}
}
 Un des constructeurs de sa classe
class Rectangle
{
double larg, long ;
Rectangle (double l, double L) {larg=l; long=L;}
Rectangle () {this(0,0);}
53
}
OBJETS ET CLASSES
~LES ATTRIBUTS
 Les attributs sont les données contenues dans les objets d’une
certaine classe.

Zarrouk Elyes
 Le nom des attributs constants est écris en majuscule
 Lors de la création d’un objet, ses attributs sont initialisés par
défaut :
 à zéro pour les valeurs numériques
 à null pour les références
 à false pour le boolean
 Les attributs peuvent être initialisés de manière spécifique par le
programmeur:
 Lors de leur déclaration
54
 Dans le constructeur
OBJETS ET CLASSES
~LES CONSTRUCTEURS
 Permettent d’initialiser les objets de la classe concernée
 Lors de la création d’un objet, un constructeur est

Zarrouk Elyes
automatiquement appelé
 Un constructeur a le même nom que la classe, ne retourne
jamais de valeur et peut prendre des paramètres
 Toute classe possède un constructeur par défaut, implicite qui
peut être redéfini.
 Une classe peut avoir plusieurs constructeurs qui diffèrent par
le nombre et la nature de leurs paramètres

55
OBJETS ET CLASSES
~LES RÉFÉRENCES
 Permettent de désigner et manipuler les objets.
 La notion de référence est assez proche de celle de pointeur

Zarrouk Elyes
 Beaucoup plus simple et sécurisant qu’un vrai pointeur
 Une référence permet d'atteindre un objet
nomClasse ref1 = new nomClasse();
 L'affectation d'une référence par une autre référence ne
copie pas l'objet mais permet de désigner le même objet
nomClasse ref2 = ref1;
 Une copie correcte d'un objet sur un autre de la même
classe duplique correctement les variables d'instance par 56
la
technique du clonage
OBJETS ET CLASSES
~LES RÉFÉRENCES
 Pour cloner correctement il faut implémenter la méthode
protégée clone de la métaclasse Object qui effectue une copie
binaire membre à membre (ne fait pas appel à un constructeur)

Zarrouk Elyes
Opérateur = Clonage correct

référence 1
valeur 1
référence 1 valeur 2
valeur 1
valeur 3
référence 2 valeur 2

valeur 3
référence 2
valeur 1
Objet à copier
valeur 2

valeur 3
57
OBJETS ET CLASSES
~LES RÉFÉRENCES
 L'égalité entre deux objets de la même classe consiste à tester si
leurs attributs respectifs ont les mêmes valeurs

Zarrouk Elyes
 Or l'opérateur ==
 ne fonctionne que sur les types de base
 car pour les autres types il compare les références et non les
objets désignés
 Il faut utiliser alors pour cela la méthode d'égalité equals de la
classe Object et la surcharger en fonction des besoins de la
classe

58
OBJETS ET CLASSES
~EXEMPLE
class Date {
int jour; // par défaut, un attribut est initialisé à zéro

Zarrouk Elyes
int mois = 1;
int an;
final int MAX_MOIS = 12; // Ceci est une constante
Date (int _an) {an = _an;} // Ceci est un constructeur
void print() {System.out.println( jour + « / » + mois + « / » + an );}
}

Date d = new Date (2002); // Création d’un nouvel objet de la
classe Date. d est une référence sur cet objet
59
d.print(); // Invocation de la méthode print
OBJETS ET CLASSES
~LA CRÉATION D’UN OBJET
 La création d’un objet se fait à l’aide de l’opérateur new qui se
charge de:

Zarrouk Elyes
1. Allouer l’espace mémoire nécessaire pour stocker les attributs de
l’objet en cours de construction
2. Appeler le constructeur de l’objet adéquat pour initialiser les
attributs de l’objet
3. Retourner une référence sur l’objet créé
 Il est possible de copier une référence et de disposer à un
instant t de plusieurs références sur un même objet

60
OBJETS ET CLASSES
~EXEMPLE 1
public class Voiture
{

Zarrouk Elyes
public String nom;
public int matricule;
public int puissance;
}
 Voiture maVoiture;
 maVoiture = new Voiture( );
 maVoiture.nom = « Golf 4 »;
 maVoiture.matricule = 66066;
 maVoiture.puissance = 6;
61
OBJETS ET CLASSES
~EXEMPLE 2
class Point implements Cloneable
{
private int x;

Zarrouk Elyes
private int y;
 
Point(int xa, int xb) { x=xa; y=xb; }
Point() { this(0,0); }
int getX() {return x;}
int getY() {return y;}
void translation(int tx, int ty) { x+=tx; y+=ty; }

// on implémente la méthode clone pour la classe Point


public Object clone() throws CloneNotSupportedException {
return super.clone(); // OK car pas de référence dans Point
}
} 62
OBJETS ET CLASSES
~EXEMPLE 2
class Segment extends Object implements Cloneable {
private Point debut;
private Point fin;
 

Zarrouk Elyes
// définition des constructeurs
Segment(int xa, int ya, int xb, int yb) {
debut = new Point(xa,ya);
fin = new Point(xb,yb);
}
Segment() { debut = new Point();
fin = new Point(); }
// méthode d'affichage d'un segment
public void affiche() {
System.out.println("\ndebut :" +debut.getX() +";"+debut.getY());
System.out.println("\nfin : " +fin.getX() +";"+fin.getY());
}
63
 
OBJETS ET CLASSES
~EXEMPLE 2
class TestClonage {
public static void main(String[] arg)throws CloneNotSupportedException
{ Segment seg = new Segment(1,1,3,3);
Segment cloneseg = (Segment) seg.clone();

Zarrouk Elyes
seg.affiche();
cloneseg.affiche();
if (seg.equals(cloneseg)==true)
System.out.println("\n les segments sont egaux");
System.out.println("\n on modifie le clone");
cloneseg.translation(4,-1);
seg.affiche();
cloneseg.affiche();
if (seg.equals(cloneseg)==true)
System.out.println("\n les segments sont egaux");
else
System.out.println("\n les segments sont differents"); }
64
}
Zarrouk Elyes
LES PACKAGES ET
L’ENCAPSULATION
65 Zarrouk Elyes
Ecole Nationale d’Ingénieurs de Sousse
LES PACKAGES ET L’ENCAPSULATION
~LES PACKAGES
 Un package regroupe un certain nombre de classes qui sont
proches dans une seule famille
 Les packages sont eux même organisés hérarchiquement

Zarrouk Elyes
 Les nom des packages suivent le schéma: name.subname

 Les packages permettent au compilateur et à la JVM de


localiser les fichier contenant les classes à charger
 L’instruction package indique à quel package la ou les
classe(s) du fichier .java

66
LES PACKAGES ET L’ENCAPSULATION
~LES PACKAGES
 Il y a deux manières d’utiliser une classe stockée dans un package:
 En utilisant le non du package suivi du nom de la classe

Zarrouk Elyes
java.util.Date now = new java.util.Date();
System.out.println(now);

En utilisant le mot clé import

import java.util.Date; // Doit être en tète du fichier


// Ne permet d’importer que la classe // Date de java.util
Date now = new Date();
System.out.println(now);

67
LES PACKAGES ET L’ENCAPSULATION
~LES PACKAGES

 Seules les classes public sont accessibles d’un autre package


 Il ne peut y avoir qu’une seule classe public dans un fichier

Zarrouk Elyes
 Les fichiers des classes qui font partie d’un package doivent
être placés dans une hiérarchie des packages

// Fichier Classe1.java dans le répertoire test/util/


package test.util;
public class Classe1{
public void test () {…}
}
68
LES PACKAGES ET L’ENCAPSULATION
~LES PACKAGES DU JAVA
java.applet Classes de base pour les Applets
java.awt Interface utilisateur
java.lang Classes faisant partie du langage
java.io Entrées/Sorties, fichiers,…
java.math Utilitaires mathématiques
java.net Accès au réseau
java.security Gestion de la sécurité
java.sql Accès aux bases de données
java.util Conteneurs, dates,…
java.util.zip Pour compresser/décompresser
Zarrouk Elyes 69
LES PACKAGES ET L’ENCAPSULATION
~L’ENCAPSULATION
 Les règles de visibilité:
 Pour les classes :
 public : accès à tous

Zarrouk Elyes
 private : accès pour les classes du même fichier
 final : une classe qui ne peut pas être héritée!!
 Pour les méthodes et les attributs
 public
 protected
 private
 friendly (prise par défaut)

70
LES PACKAGES ET L’ENCAPSULATION
~L’ENCAPSULATION
 le mot clé final
 pour une variable : constante
 pour une méthode : cette méthode ne peut pas être redéfinie dans une classe

Zarrouk Elyes
dérivée
 pour une classe : cette classe ne peut plus être étendu (dérivée, spécialisée)
 Exemples : final int n ; final double Perimetre() ; final Cercle extends … ;
 Une variable finale doit être initialisée.

Attention, pour une classe, limite sa réutilisabilité


 Sécurité

71
LES PACKAGES ET L’ENCAPSULATION
~L’ENCAPSULATION
Accessible Méthodes de Classes Classes Classes Classes des
aux : la même dérivées du même dérivées autres
classe dans le package dans un package
même autre
package package
public X X X X X

protected X X X X

friendly X X X

private X

Zarrouk Elyes 72
LES PACKAGES ET L’ENCAPSULATION
~L’ENCAPSULATION
 Pour respecter l’encapsulation des objets :
1. Les attributs doivent toujours être privés

Zarrouk Elyes
2. Les attributs constants (final) peuvent être publics ou
privés
3. Les méthodes à usage strictement interne doivent être
privées
4. Si un attribut doit pouvoir être accessible de l’extérieur :
définir des méthodes publiques permettant d’y accéder

73
LES PACKAGES ET L’ENCAPSULATION
~L’ENCAPSULATION
class Personne {
private String nom;

Zarrouk Elyes
public Personne( String nom) {this.nom = nom;}
public String getNom( ) {return nom;}
}


Personne moi = new Personne ("Abdelhedi " );
System.out.println (moi.getNom( ));

74
LES PACKAGES ET L’ENCAPSULATION
~ LES ATTRIBUTS STATIQUES
 static :
 Permet d’indiquer que cet attribut est commun à tous
les objets de la classe concerné

Zarrouk Elyes
 Un attribut static peut être accédé par le nom de la
classe elle-même

75
LES PACKAGES ET L’ENCAPSULATION
~ LES ATTRIBUTS STATIQUES
class Rectangle {
static int NbrRectangles = 0;

Zarrouk Elyes
Rectangle(){NbrRectangles ++;}
int getNbrRectangles () { return NbrRectangles ; }
}

Utilisation
Rectangle p1=new Rectangle ();
Rectangle p2=new Rectangle ();

p1.getNbrPoints() --> 2 76
p2.getNbrPoints() --> 2
LES PACKAGES ET L’ENCAPSULATION
~ LES MÉTHODES STATIQUES
 Définies avec le mot clé static
 Elles ressemblent aux fonctions globales dans des autres
langages de programmation

Zarrouk Elyes
 Elles ne peuvent accéder que les attributs static
 On fait appel à une méthode statique à travers le nom de la
classe
ClassName.functionName(arguments);
 Par exemple, la classe Math à une méthode statique appelé
cos qui prend une valeur de type double comme argument
Math.cos(3.5)
 La méthode main est statique – parce que le système appelle
main avant de créer des objets
77
LES PACKAGES ET L’ENCAPSULATION
~CLASSES IMBRIQUÉES ET CLASSES ANONYMES
 Il est possible de définir des classes dans des classes :
 Les classes imbriquées : Elles possèdent un nom et sont
définies au même niveau qu’une méthode ou un attribut

Zarrouk Elyes
 Les classes anonymes : Elles ne possèdent pas de nom et
sont définies là où elles sont utilisées
 La visibilité de ces classes est limitée aux méthodes de la
classe dans lesquelles elles sont définies
 Elles ont accès à tous les éléments de cette classe (même
privés)

78
LES PACKAGES ET L’ENCAPSULATION
~CLASSES IMBRIQUÉES ET CLASSES
ANONYMES
class PileEnt {
private int s; pivate int p[ ] = new int[100];
public PileEnt ( ) {s = -1;}
public void empiler (int e) {s = s+1; p[s] = e;}

Zarrouk Elyes
public void depiler ( ) { s = s-1;}
public int sommet ( ) {return p[s];}
public class Parcours {
private int courant;
public Parcours ( ) { courant = s;}
public void suivant ( ) { courant --;}
public int element ( ) { return p[courant]; }
}
}
PileEnt p = new PileEnt ( ); …
PileEnt.Parcours parc1 = p.new Parcours ( );
PileEnt.Parcours parc2 = p.new Parcours ( ); 79
Parc1.element (); parc2.element ( );
Zarrouk Elyes
LES TABLEAUX ET LES
VECTEURS DYNAMIQUES EN
JAVA
80 Zarrouk Elyes
Ecole Nationale d’Ingénieurs de Sousse
LES TABLEAUX ET LES VECTEURS DYNAMIQUES
~INTRODUCTION
 En programmation, on parle de tableau pour désigner un
ensemble d’éléments de même type désignés par un nom
unique, chaque élément étant repéré par un indice précisant

Zarrouk Elyes
sa position au sein de l’ensemble.
 Comme tous les langages, Java permet de manipuler des
tableaux mais nous verrons qu’il fait preuve d’originalité sur
ce point. En particulier, les tableaux sont considérés comme
des objets et les tableaux à plusieurs indices s’obtiennent par
composition de tableaux.

81
LES TABLEAUX ET LES VECTEURS DYNAMIQUES
~INTRODUCTION
 En Java, les tableaux ne sont pas extensibles!!!!
Pour augmenter la taille on doit donc créer un

Zarrouk Elyes
nouveau tableau plus grand, puis copier toutes les valeurs de
l'ancien tableau dans le nouveau.
Utiliser des listes, les vecteurs dynamiques, les
ensembles…

82
LES TABLEAUX ET LES VECTEURS DYNAMIQUES
~LES TABLEAUX
 Les tableaux et les objets de type classe présentent les points
communs suivants :

Zarrouk Elyes
 Ilssont toujours manipulés par référence
 Leur déclaration ne fait qu’associer l’identificateur à une
variable de nature référence initialisée à null.
 Pour que cet identificateur désigne un objet, il faut lui affecter
soit le résultat d’une création, grâce à la primitive new, soit un
objet déjà existant.

83
LES TABLEAUX ET LES VECTEURS DYNAMIQUES
~LES TABLEAUX

Un tableau se déclare ainsi :


int T[]; tableau d’entiers

Zarrouk Elyes
Robot R[]; tableau d’éléments de type Robot
La taille d’un tableau n’est pas indiquée dans la déclaration,
mais au moment de la création d’un tableau, de la façon
suivante :
T=new int[20]; crée un tableau de 20 entiers, référencé par T
R=new Robot[5]; crée un tableau de 5 objets de type Robot,
référencé par R

84
LES TABLEAUX ET LES VECTEURS DYNAMIQUES
~LES TABLEAUX
 Les indices des tableaux commencent à 0.
 L’accès à un élément se note ainsi : T[15]

Zarrouk Elyes
 On peut connaître la taille d’un tableau T par l’attribut
T.length.
 Java n’offre pas de notion spécifique pour les tableaux à
plusieurs dimensions : on les réalise simplement comme des
tableaux de tableaux.
 int M[][]; tableau de tableaux d’entiers.

85
LES TABLEAUX ET LES VECTEURS DYNAMIQUES
~LES TABLEAUX
 Ces trois déclarations sont équivalentes :
 int t [] [] ;int [] t [] ;int [] [] t ;

Zarrouk Elyes
 Elles déclarent que t est une référence à un tableau, dans
lequel chaque élément est lui-même une référence à un
tableau d’entiers. Pour l’instant, comme à l’accoutumée,
aucun tableau de cette sorte n’existe encore.
 Mais considérons la déclaration :

 int t [] [] = { new int [3], new int [2] } ;


 L’initialiseurde t comporte deux éléments dont l’évaluation crée
un tableau de 3 entiers et un tableau de 2 entiers. On aboutit à cette
situation (les éléments des tableaux d’entiers sont,comme
86
d’habitude, initialisés à 0)
LES TABLEAUX ET LES VECTEURS DYNAMIQUES
~LES TABLEAUX
 Dans ces conditions, on voit que :
 la notation t[0] désigne la référence au premier tableau de 3 entiers,

Zarrouk Elyes
 la notation t[0][1] désigne le deuxième élément de ce tableau (les
indices commencent à 0),
 la notation t[1] désigne la référence au second tableau de 2 entiers,
 la notation t[1][i-1] désigne le ième élément de ce tableau,
 l’expression t.length vaut 2,
 l’expression t[0].length vaut 3,
 l’expression t[1].length vaut 2.

87
LES TABLEAUX ET LES VECTEURS DYNAMIQUES
~LES TABLEAUX: EXEMPLE

int [][]t= new int[5][];

Zarrouk Elyes
for (int i=0; i<t.length; i++) {
[0] [1] [2] [3] [4]
t[i]=new int[5-i];
t[0] 0 1 2 3 4
}
t[1] 1 2 3 4
for (int i=0; i<t.length; i++) {
t[2] 2 3 4
for (int j=0; j<t[i].length; j++) {
t[3] 3 4
t[i][j]=i+j;
t[4] 4
}}
Par conséquent, il n'est pas nécessairement carré 88
LES TABLEAUX ET LES VECTEURS
DYNAMIQUES
~LA CLASSE JAVA.UTIL.VECTOR
 Cette classe gère une collection d’objets dans un tableau
dynamique
 Exemple

Zarrouk Elyes
Vector vec = new Vector() ;
for (int i=0 ; i<10 ; i++) {Integer element = new Integer(i) ;
vec.addElement(element) ;}// Ajout en fin de Vecteur
// => 0 1 2 3 4 5 6 7 8 9
Integer i = new Integer(15) ;

89
LES TABLEAUX ET LES VECTEURS DYNAMIQUES
~LA CLASSE JAVA.UTIL.VECTOR
vec.insertElementAt(i,5) ; // Insertion à la position indiquée
// => 0 1 2 3 4 15 5 6 7 8 9

Zarrouk Elyes
vec.removeElementAt(0) ; // Suppression de l'élément indiqué
// => 1 2 3 4 15 5 6 7 8 9Integer j = (Integer)vec.elementAt(6) ;
// j contient une référence sur l'objet Integer contenant
vec.removeAllElements() ; // Suppression de tous les éléments
// =>

90
LES TABLEAUX ET LES VECTEURS DYNAMIQUES
~LA CLASSE JAVA.UTIL.VECTOR
 Autres méthodes disponibles :
 Object elementAt(int index) : retourne (sans retirer)

Zarrouk Elyes
l'élément à la position index
 void setElementAt(Object obj) : place l'objet à la
position indiquée (remplacement)
 boolean contains(Object obj) : retourne true si obj est
dans le tableau
 int indexOf(Object obj) : retourne la position de obj (-1
si obj n'est pas présent)
 int size() : retourne la taille du tableau

91
LES TABLEAUX ET LES VECTEURS DYNAMIQUES
~LA CLASSE JAVA.UTIL.VECTOR: EXEMPLE
// pour trier le conteneur il faut d'abord spécifier que la classe
// Personnel implémente l'interface Comparable et il faut définir
// ensuite la méthode compareTo de la classe Personnel

Zarrouk Elyes
// ici on veut trier par le numéro de téléphone
 
public int compareTo(Object p) {
return numTel.compareTo(((Personnel)p).numTel);
}
 
 
// on effectue le tri du conteneur en invoquant la méthode sorte de
// la classe Collections
//ATTENTION ne pas confondre avec l'interface Collection (sans s)
 
Collections.sort(conteneur);
 
// pour vider totalement le conteneur 92
conteneur.clear();
Zarrouk Elyes
L’HÉRITAGE EN JAVA
93 Zarrouk Elyes
Ecole Nationale d’Ingénieurs de Sousse
L’HÉRITAGE
~DÉFINITIONS
 On a parfois besoin de définir un type d’objet similaire à
un type existant, avec quelques propriétés
supplémentaires.

Zarrouk Elyes
 L’héritage permet de définir ce nouveau type sans tout
reprogrammer : il suffit de déclarer que le nouveau type
hérite du précédent et on se borne à rédiger ses
fonctionnalités supplémentaires.

94
L’HÉRITAGE
~DÉFINITIONS
 Toute classe en Java est sous classe de la classe Object
 Une seule classe ne peut hériter que d’une seule classe

Zarrouk Elyes
 Spécification d’une relation spécialisation /
généralisation

95
L’HÉRITAGE
~DÉFINITIONS
 Si A hérite B
 A possède tous les caractéristiques de B et aussi d’autres

Zarrouk Elyes
caractéristiques qui sont spécifiques à A
 A est une spécification de B
 B est une généralisation de A
 A est appelée classe dérivée(fille)
 B est appelée classe de base(mère ou super-classe)
 Tout objet instancié de A est considéré aussi comme objet de
type B
 Un objet de type B n’est pas forcément un objet de type A
96
L’HÉRITAGE
~CONCEPTS DE BASE
 L’héritage est représenté par la notion d’extension « extends »
 Une référence de type d’objet B peut référencier un objet de

Zarrouk Elyes
type A
 La déclaration de l’héritage en Java suit la syntaxe suivante:

[modificateur] classe Classe_Dérivée extends Classe_De_Base

97
L’HÉRITAGE
~CONCEPTS DE BASE
 Définition du constructeur
 A l’appel de super, java appelle le constructeur de la

Zarrouk Elyes
classe de base convenable
 Par défaut, java appelle le constructeur par défaut de la
classe de base
 Accès aux membres hérités (au sein de la classe
dérivée)
 Si attributs ou méthodes sont privés: Interdit d’accéder
malgré qu’ils font parti de sa description
 SI protected  autorisation d’accès
 Si autorisé on accède par super.membre 98
L’HÉRITAGE
~CONCEPTS DE BASE
 L’opérateur instanceof permet de savoir à quelle classe
appartient une instance : 

Zarrouk Elyes
class B{ …}
class D extends B{…}
class C {…}
B b = new B();
D d = new D();
C c = new C();
b instanceof B // true
b instanceof D // false
d instanceof B // true
99
d instanceof D // true
L’HÉRITAGE
~CONCEPTS DE BASE
b = d;
b instanceof B // true

Zarrouk Elyes
b instanceof D // true
c instanceof B // erreur de compilation Erreur No. 365 : //
impossible de comparer C avec B en ligne …, colonne ..
Exemple  la méthode equals(Object o), pour une classe X,
est définie, en général, de la façon suivante :
 public boolean equals(Object o){

if(this==o) return true; if(!(o instanceof X) return false;


X x = (X)o; ... }
100
L’HÉRITAGE
~REDÉFINITION DES MÉTHODES

• Une méthode héritée peut être redéfinie si sa version


initiale n’est pas satisfaisante pour la classe dérivée

Zarrouk Elyes
• La redéfinition consiste à conserver l’entête de la
méthode et à proposer un code différent (il est de
redéfinir une méthode de l’ancienne version par
super.nom_méthode()
• Après la redéfinition, seule la nouvelle version qui fait
parti de la description de la classe dérivée.

101
L’HÉRITAGE
~REDÉFINITION DES MÉTHODES
public class Ellipse {
public double r1, r2;
public Ellipse(double r1, double r2) {

Zarrouk Elyes
this.r1 = r1;
this.r2 = r2;
}
public double area (){…}
void print() {}
}

final class Circle extends Ellipse {


public Circle(double r) {super(r,r);}
public double getRadius () {return r1;}
void print () {System.out.println (" le rayon est : "  + r1);}
102
L’HÉRITAGE
~REDÉFINITION DES MÉTHODES
Ellipse e = new Ellipse (2.0, 4.0);
Circle c = new Circle(2.0);
c.print();//appeler la méthode print() de la classe cercle

Zarrouk Elyes
System.out.println( e instanceof Ellipse); //true
System.out.println( e instanceof Circle); //false
System.out.println( c instanceof Circle); //true
System.out.println( c instanceof Ellipse); //true
e = c; // OK : tout cercle est une ellipse
System.out.println( e instanceof Circle); //true
System.out.println( e instanceof Ellipse); //true
e.print() // la référence e est de type Ellipse mais l’objet réellement référencé est de
type Circle => c’est la méthode Circle.print() qui est réellement appelé
double r = e.getRadius() // erreur à la compilation
c = e; // erreur type incompatible, nécessité de casting
c = (Circle) e;
103
L’HÉRITAGE
~REDÉFINITION DES MÉTHODES
class Mere { int attribut;
Mere() {attribut = 1;}
Mere(int attribut) {this.attribut = attribut;}

Zarrouk Elyes
void print() {System.out.println(" base"+ attribut);}}
class Fille extends Mere {
boolean flag;
Fille(int a) { super(a); flag = true; }
void print() { System.out.println(" dérivée");
super.print(); } }
…….
……. Fille f = new Fille(2);
Mere m = f;
m.print();
// affiche :
dérivée
base 2 104
L’HÉRITAGE
~SURDÉFINITION DES MÉTHODES
class A
{ public void f(double x) { System.out.print ("A.f(double=" + x +") ") ; }
}

Zarrouk Elyes
class B extends A {}
class C extends A
{ public void f(long q) { System.out.print ("C.f(long=" + q + ") ") ; }
}
class D extends C
{ public void f(int n) { System.out.print ("D.f(int=" + n + ") ") ; }
}
class E extends B {}
class F extends C
{ public void f(float x) { System.out.print ("F.f(float=" + x + ") ") ; }
public void f(int n) { System.out.print ("F.f(int=" + n + ") ") ; }
} 105
L’HÉRITAGE
~SURDÉFINITION DES MÉTHODES
public class Surdf
{ public static void main (String arg[])
{ byte bb=1 ; short p=2 ; int n=3 ; long q=4 ;

Zarrouk Elyes
float x=5.f ; double y=6. ;
A a = new A() ; a.f(bb) ; a.f(x) ;
System.out.println() ;
B b = new B() ; b.f(bb) ; a.f(x) ;
System.out.println() ;
C c = new C() ; c.f(bb) ; c.f(q) ; c.f(x) ;
System.out.println() ;
D d = new D() ; d.f(bb) ; c.f(q) ; c.f(y) ;
System.out.println() ;
E e = new E() ; e.f(bb) ; e.f(q) ; e.f(y) ;
System.out.println() ;
F f = new F() ; f.f(bb) ; f.f(n) ; f.f(x) ; f.f(y) ; f.f(p) ; 106

}}
Zarrouk Elyes
LE POLYMORPHISME EN JAVA
107 Zarrouk Elyes
Ecole Nationale d’Ingénieurs de Sousse
LE POLYMORPHISME EN JAVA
~INTRODUCTION
 En P.O.O., une classe peut "redéfinir" (c’est-à-dire modifier)
certaines des méthodes héritées de sa classe de base. Cette
possibilité est la clé de ce que l’on nomme le

Zarrouk Elyes
"polymorphisme", c’est-à-dire la possibilité de traiter de la
même manière des objets de types différents, pour peu qu’ils
soient issus de classes dérivées d’une même classe de base.
 Il s’agit d’un concept extrêmement puissant en P.O.O., qui
complète l’héritage. On peut caractériser le polymorphisme
en disant qu’il permet de manipuler des objets sans en
connaître (tout à fait) le type.

108
LE POLYMORPHISME EN JAVA
~LES CONCEPTS DE BASE
 Le polymorphisme en Java se traduit par :
• la compatibilité par affectation entre un type classe et un

Zarrouk Elyes
type ascendant,
• la ligature dynamique des méthodes.
 Le polymorphisme permet d’obtenir un comportement adapté
à chaque type d’objet, sans avoir besoin de tester sa nature de
quelque façon que ce soit. La richesse de cette technique
amène parfois à dire que l’instruction switch est à la P.O.O.

109
LE POLYMORPHISME EN JAVA
~LES CONCEPTS DE BASE
class Point
{ public Point (int x, int y) { ..... }
public void affiche () { ..... }

Zarrouk Elyes
}
class Pointcol extends Point
{ public Pointcol (int x, int y, byte couleur)
public void affiche () { ..... }
}
Point p ;
p = new Point (3, 5) ;
Mais il se trouve que Java autorise ce genre d’affectation (p étant toujours
de type Point)
p = new Pointcol (4, 8, (byte)2) ; // p de type Point contient la référence 110
// à un objet de type Pointcol
LE POLYMORPHISME EN JAVA
~LES CONCEPTS DE BASE
 Point p = new Point (3, 5) ;
 p.affiche () ; // appelle la méthode affiche de la classe

Zarrouk Elyes
Point
 p = new Poincol (4, 8, 2) ;

 p.affiche () ; // appelle la méthode affiche de la classe


Pointcol

111
LE POLYMORPHISME EN JAVA
~LES CONCEPTS DE BASE
class Point
{ public Point (int x, int y)
{ this.x = x ; this.y = y ; }

Zarrouk Elyes
public void deplace (int dx, int dy)
{ x += dx ; y += dy ; }
public void affiche ()
{ System.out.println ("Je suis en " + x + " " + y) ; }
private int x, y ;}
class Pointcol extends Point
{ public Pointcol (int x, int y, byte couleur)
{ super (x, y) ; // obligatoirement comme première instructio
this.couleur = couleur ; }
public void affiche ()
{ super.affiche() ;
System.out.println (" et ma couleur est : " + couleur) ; } 112

private byte couleur ;}


LE POLYMORPHISME EN JAVA
~LES CONCEPTS DE BASE
public class Poly
{ public static void main (String args[])
{ Point p = new Point (3, 5) ;

Zarrouk Elyes
p.affiche() ; // appelle affiche de Point
Pointcol pc = new Pointcol (4, 8, (byte)2) ;
p = pc ; // p de type Point, reference un objet de type Pointcol
p.affiche() ; // on appelle affiche de Pointcol
p = new Point (5, 7) ; // p reference a nouveau un objet de type Point
p.affiche() ; // on appelle affiche de Point
}
}
========
Je suis en 3 5
Je suis en 4 8
et ma couleur est : 2 113
Je suis en 5 7
LE POLYMORPHISME EN JAVA
~LES CONCEPTS DE BASE
public class TabHeter
{ public static void main (String args[])
{ Point [] tabPts = new Point [4] ;

Zarrouk Elyes
tabPts [0] = new Point (0, 2) ;
tabPts [1] = new Pointcol (1, 5, (byte)3) ;
tabPts [2] = new Pointcol (2, 8, (byte)9) ;
tabPts [3] = new Point (1, 2) ;
for (int i=0 ; i< tabPts.length ; i++) tabPts[i].affiche() ;
}
}
==
Je suis en 0 2
Je suis en 1 5
et ma couleur est : 3
Je suis en 2 8
et ma couleur est : 9 114
Je suis en 1 2
LE POLYMORPHISME EN JAVA
~LES CONCEPTS DE BASE
class Point
{ public Point (int x, int y)

Zarrouk Elyes
{ this.x = x ; this.y = y ;
}
public void affiche ()
{ identifie() ;
System.out.println (" Mes coordonnees sont : " + x + " " + y) ;
}
public void identifie ()
{ System.out.println ("Je suis un point ") ;
}
private int x, y ; 115
}
LE POLYMORPHISME EN JAVA
~LES CONCEPTS DE BASE
class Pointcol extends Point
{

Zarrouk Elyes
public Pointcol (int x, int y, byte couleur)
{ super (x, y) ;
this.couleur = couleur ;
}

public void identifie ()


{ System.out.println ("Je suis un point colore de couleur " + couleur)
;
}
private byte couleur ; 116
}
LE POLYMORPHISME EN JAVA
~LES CONCEPTS DE BASE
Considérons alors ces instructions :
Pointcol pc = new Pointcol (8, 6, (byte)2) ;

Zarrouk Elyes
pc.affiche () ;
 L’instruction pc.affiche() entraîne l’appel de la méthode
affiche de la classe Point (puisque cette méthode n’a pas
été redéfinie dans Pointcol). Mais dans la méthode
affiche de Point, l’instruction identifie() appelle la
méthode identifie de la classe correspondant à l’objet
effectivement concerné (autrement dit, celui de référence
this). Comme ici, il s’agit d’un objet de type Pointcol, il
y aura bien appel de la méthode identifie de Pointcol.
117
LE POLYMORPHISME EN JAVA
~LES CONCEPTS DE BASE
public class TabHet2{ public static void main (String args[])
{ Point [] tabPts = new Point [4] ;
tabPts [0] = new Point (0, 2) ;

Zarrouk Elyes
tabPts [1] = new Pointcol (1, 5, (byte)3) ;
tabPts [2] = new Pointcol (2, 8, (byte)9) ;
tabPts [3] = new Point (1, 2) ;
for (int i=0 ; i< tabPts.length ; i++) tabPts[i].affiche() ; }}
 Je suis un point
Mes coordonnees sont : 0 2
Je suis un point colore de couleur 3
Mes coordonnees sont : 1 5
Je suis un point colore de couleur 9
Mes coordonnees sont : 2 8
Je suis un point 118
Mes coordonnees sont : 1 2
LE POLYMORPHISME EN JAVA
~LES CONCEPTS DE BASE
class A
{ public void f(float x)

Zarrouk Elyes
{ System.out.print ("A.f(float=" + x +") ") ; }
}
class B extends A
{ public void f(float x)
{ System.out.print ("B.f(float=" + x + ") ") ; }
public void f(int n)
{ System.out.print ("B.f(int=" + n + ") ") ; }
} 119
LE POLYMORPHISME EN JAVA
~LES CONCEPTS DE BASE
public class PolySur
{ public static void main (String arg[])

Zarrouk Elyes
{int n=3 ;
float x=5.f ;
System.out.println ("** A ** ") ;
A a = new A() ; a.f(n) ; a.f(x) ; System.out.println() ;
System.out.println ("** B ** ") ;
B b = new B() ; b.f(n) ; b.f(x) ; System.out.println() ;
a = b ; a.f(n) ; a.f(x) ;}} 120
LE POLYMORPHISME EN JAVA
~GÉNÉRALISATION

Zarrouk Elyes
* Une classe définissant ou redéfinissant une méthode f
121
LE POLYMORPHISME EN JAVA
~GÉNÉRALISATION
Avec ces déclarations :
Aa;Bb;Cc;Dd;Ee;Ff;

Zarrouk Elyes
les affectations suivantes sont légales :
a = b ; a = c ; a = d ; a = e ; a =f ;
b=d;b=e;
c=f;
En revanche, celles-ci ne le sont pas :
b = a ; // erreur : A ne descend pas de B
d = c ; // erreur : C ne descend pas de D
c = d ; // erreur : D ne descend pas de C 122
LE POLYMORPHISME EN JAVA
~GÉNÉRALISATION
Voici quelques exemples précisant la méthode f appelée,
selon la nature de l’objet effectivement référencé par a
(de type A) :

Zarrouk Elyes
a référence un objet de type A : méthode f de A
a référence un objet de type B : méthode f de A
a référence un objet de type C : méthode f de C
a référence un objet de type D : méthode f de D
a référence un objet de type E : méthode f de A
a référence un objet de type F : méthode f de C.

123
LE POLYMORPHISME EN JAVA
~SURDÉFINITION DES MÉTHODES
class A
{ public void f(double x) { System.out.print ("A.f(double=" + x +") ") ; }
}

Zarrouk Elyes
class B extends A {}
class C extends A
{ public void f(long q) { System.out.print ("C.f(long=" + q + ") ") ; }
}
class D extends C
{ public void f(int n) { System.out.print ("D.f(int=" + n + ") ") ; }
}
class E extends B {}
class F extends C
{ public void f(float x) { System.out.print ("F.f(float=" + x + ") ") ; }
public void f(int n) { System.out.print ("F.f(int=" + n + ") ") ; }
} 124
LE POLYMORPHISME EN JAVA
~SURDÉFINITION DES MÉTHODES
public class Surdf
{ public static void main (String arg[])
{ byte bb=1 ; short p=2 ; int n=3 ; long q=4 ;

Zarrouk Elyes
float x=5.f ; double y=6. ;
A a = new A() ; a.f(bb) ; a.f(x) ;
System.out.println() ;
B b = new B() ; b.f(bb) ; a.f(x) ;
System.out.println() ;
C c = new C() ; c.f(bb) ; c.f(q) ; c.f(x) ;
System.out.println() ;
D d = new D() ; d.f(bb) ; c.f(q) ; c.f(y) ;
System.out.println() ;
E e = new E() ; e.f(bb) ; e.f(q) ; e.f(y) ;
System.out.println() ;
F f = new F() ; f.f(bb) ; f.f(n) ; f.f(x) ; f.f(y) ; f.f(p) ; 125

}}
L’HÉRITAGE
~SURDÉFINITION DES MÉTHODES
Affichage sur l’ecran:

A.f(double=1.0) A.f(double=5.0)

Zarrouk Elyes
A.f(double=1.0) A.f(double=5.0)
C.f(long=1) C.f(long=4) A.f(double=5.0)
D.f(int=1) C.f(long=4) A.f(double=6.0)
A.f(double=1.0) A.f(double=4.0) A.f(double=6.0)
F.f(int=1) F.f(int=3) F.f(float=5.0) A.f(double=6.0) C.f(long=4) F.f(int=2)

126
Zarrouk Elyes
LES CLASSES ABSTRAITES ET LES
INTERFACES
127 Zarrouk Elyes
Ecole Nationale d’Ingénieurs de Sousse
LES CLASSES ABSTRAITES ET LES
INTERFACES
~INTRODUCTION
 Une méthode abstraite est une méthode dont on donne le
prototype, sans décrire l’implémentation
 Une méthode abstraite doit être redéfinie dans une sous-

Zarrouk Elyes
classe pour pouvoir être utilisée
 Une classe abstraite ne peut jamais être directement
instanciée avec l’opérateur new
 Une classe héritant d’une classe abstraite doit donner une
implémentation à toutes les méthodes abstraites de sa super-
classe

128
LES CLASSES ABSTRAITES ET LES
INTERFACES
~INTRODUCTION
 Une classe abstraite est une classe ayant au moins une
méthode abstraite.

Zarrouk Elyes
 Une méthode abstraite est une méthode dont on donne le
prototype, sans décrire l’implémentation
 Une classe abstraite ne peut pas être instancié (new)

 Une classe dérivée d’une classe abstraite ne redéfinissant


pas toutes les méthodes abstraites est elle même abstraite

129
LES CLASSES ABSTRAITES ET LES
INTERFACES
~LES CLASSES ABSTRAITES
class abstract Shape {
public abstract double perimeter ( );
}

Zarrouk Elyes
class Circle extends Shape {

public double perimeter ( ) { return 2*Math.PI*r; }
}
class Rectangle extends Shape {

public double perimeter ( ) { return 2*( height +width ); }
}

Shape[ ] shapes = { new Circle(2), new Rectangle(2,3), new Circle( 6 ) };
double sum_of_perimeters = 0;
for (int i = 0; i < shapes.length; i++) 130
sum_of_perimeters = shapes[i].perimeter( );
LES CLASSES ABSTRAITES ET LES INTERFACES
~INTERFACES
 Une interface correspond à une classe abstraite ne
contenant que des méthodes abstraites et que des attributs
final et static

Zarrouk Elyes
 Une classe peut implémenter (implements) une ou
plusieurs interfaces tout en héritant (extends) d’une classe
 Les attributs déclarés dans une interface sont
obligatoirement des constantes statiques
 Une interface peut hériter (extends) de plusieurs interfaces
 L’opérateur instanceof peut être utilisé pour savoir si un
objet implémente une interface donné
 Des objets différents peuvent être utilisés de la même
manière à condition qu’ils implémentent la même interface 131
LES CLASSES ABSTRAITES ET LES INTERFACES
~LES INTERFACES
class abstract Shape {
public abstract double perimeter ( );
}

Zarrouk Elyes
intreface Drawable {public void draw( );}
class Circle extends Shape implements Drawable {

public double perimeter ( ) { return 2 * Math.PI * r;}
public void draw ( ) {…}
}
class Rectangle extends Shape implements Drawable {

public double perimeter ( ) { return 2 * ( height + width);}
public void draw ( ) {…}
}
Drawable[ ] drawables = {new Circle(2), new Rectangle(2, 3), new Circle(5)};
For (int i = 0, i < drawables.length; i++) 132
drawables[i].draw( );
LES CLASSES ABSTRAITES ET LES INTERFACES
~LES INTERFACES
Personnel
Nom: String
Poste: String
Salaire: Float

Zarrouk Elyes
Personnel()
Personnel( String Nom, String poste, Float salaire)
void affiche()

Employe Directeur
montant: int Prime: long

Directeur()
Employe() Directeur( String Nom, String poste, long prime,Float
Employe( String Nom, String poste, Float salaire, salaire)
int montant) void affiche()
void affiche() 133
LES CLASSES ABSTRAITES ET LES INTERFACES
~LES INTERFACES
// utilisation de la classe Vector
 // définition d'une instance de Vector de 20 éléments et dont la
// capacité est augmentée de 5 si débordement

Zarrouk Elyes
Vector conteneur = new Vector(20,5);
 
// on ajoute 2 instances de la hiérarchie Personnel
conteneur.add(new Employe("dupond","poste 2091",20.50f,160));
conteneur.add(new Directeur("BigBoss","top secret",85000, 2500.45f));
 
// variable temporaire
Personnel temp = new Employe("toto","--",20.50f,160);
// insère l'objet temp en deuxième position dans le conteneur
conteneur.add(1,temp);
 
// affichage du contenu du vecteur
for (int i=0; i<conteneur.size();i++) {
System.out.println("\n\n Caracteristiques du salarie : ");
((Personnel)conteneur.get(i)).affiche(); 134
}
LES CLASSES ABSTRAITES ET LES INTERFACES
~LES INTERFACES
// définition d'un itérateur
Iterator it = conteneur.iterator();
 

Zarrouk Elyes
 
// affichage du contenu du vecteur par l'iterateur
while (it.hasNext()) {
System.out.println("\n\n Caracteristiques du salarie : ");
((Personnel)it.next()).affiche();
}
 
// conversion du vecteur en un tableau de Personnel
Personnel tabSalarie[] = new Personnel[conteneur.size()];
tabSalarie = (Personnel[])conteneur.toArray(tabSalarie);
 
 
// affichage du contenu du tableau
for (int i=0;i<3;i++) {
System.out.println("\n\n Caracteristiques du salarie : "); 135
tabSalarie[i].affiche(); }
LES CLASSES ABSTRAITES ET LES INTERFACES
~LES INTERFACES
// supprimer la référence sur le deuxième élément
conteneur.remove(1);
 

Zarrouk Elyes
// ou bien si on veut garder une référence sur l'élément supprimé
Personnel recup = (Personnel) conteneur.remove(1);
System.out.println("\n\n Caracteristiques du salarie supprime: ");
recup.affiche();
 
// pour rechercher l'occurrence d'un élément il faut avoir surcharger
// la méthode equals pour le type de l'élément
// ici dans la hiérarchie Personnel le critère choisi est le nom
boolean equals(Personnel p) { return nomPers.equals(p.nomPers); }
 
// on recherche ensuite d ans le conteneur par la méthode indexOf
i = conteneur.indexOf(temp);
 
System.out.println("\n\n le salarie recherche est a la position: "+i); 136