CoursLicencePOO2017 PDF

21/02/2017
Université Hassan II - Casablanca

Faculté des Sciences et Techniques de Mohammedia
Département informatique
PROGRAMMATION MULTIMEDIA MOBILE
Partie 1 : les concepts de la programmation orientée objet (en java)
Mohammed Amine NOUA

a.noua@yahoo.fr
Mohammed Amine NOUA Partie 1 : les concepts de la POO
Plan
Mohammed Amine NOUA Partie 1 : les concepts de la POO
1
21/02/2017
Partie 1 : les concepts de la POO Introduction
Dans les programmes que vous avez écrits jusqu’à maintenant, les notions:
• De variables/types de données
• Et de traitement de ces données
Étaient séparées :
Opèrent sur
traitements données
influencent
2
21/02/2017
Un des objectifs principaux de la notion d’objet:
Organiser des programmes complexes grâce aux notions:
• D’encapsulation
• D’abstraction
• D’héritage
• Et de polymorphisme
Partie 1 : les concepts de la POO Encapsulation & abstraction
Principe d’encapsulation:
Regrouper dans le même objet informatique les données et les traitements
qui lui sont spécifiques:
• Attributs : les données incluses dans un objet

• Méthodes : les fonctions définies dans un objet
Les objets sont définis par leurs attributs et leurs méthodes.
3
21/02/2017
Le processus d’abstraction consiste à identifier pour un ensemble

d’éléments :
• Des caractéristiques communes à tous les éléments

• Des mécanismes communs à tous les éléments
→ se focaliser sur l’essen<el, cacher les détails.
L’interface d’une voiture :
• Volant, accélérateur, pédale de frein, etc.

• Tout ce qu’il faut savoir pour la conduire mais pas la réparer! Ni
comprendre comment ça marche.
• L’interface ne change pas, même si l’on change de moteur…
→ abstrac<on de la no<on de voiture (en tant qu’objet à conduire)
4
21/02/2017
En plus du regroupement des données et des traitements relatifs à une

entité, l’encapsulation permet en effet de définir deux niveaux :
• Niveau externe : partie visible par les programmeurs-utilisateurs :

→ l’interface : entête de quelques méthodes bien choisies
→ résultat du processus d’abstrac<on
• Niveau interne : détails d’implémentation :

→ méthodes et aCributs accessibles uniquement depuis l’intérieur
de l’objet.
Programmeur Programmeur
Utilisateur Concepteur/développeur
accord
Interface
Définition d’un
Utilisation du type nouveau type
(classe)
10
5
21/02/2017
11
Partie 11: :les

Chapitre concepts deà la POO Encapsulation & abstraction
Introduction
12
6
21/02/2017
13
Partie 1 : les concepts de la POO Classes, objets, attributs et méthodes
En programmation objet :
• Le résultat des processus d’encapsulation

et d’abstraction s’appelle une classe
Classe = catégorie d’objets
• Une classe définit un type
• Une réalisation particulière d’une classe
s’appelle une instance
instance = objet
• Un objet est une variable
14
7
21/02/2017
En java une classe se déclare par le mot-clé class.
Exemple : class Rectangle { …}
Ceci définit un nouveau type du langage.
La déclaration d’une instance d’une classe se fait de façon similaire à la

déclaration d’une variable : nomClasse nomInstance;
Exemple:
Rectangle rect1; // déclare une instance rect1 de la classe Rectangle.
15
1. Déclaration de plusieurs classes dans le même fichier : la classe Rectangle

et la classe qui l’utilise Dessin déclarées dans Dessin.java
> javac Dessin.java
Produit les fichiers:
Dessin.class
Rectangle.class
Le compilateur crée un fichier .class

pour chaque classe.
16
8
21/02/2017
2. Déclaration de chaque classes dans un fichier à part :
->Rectangle déclarée dans Rectangle.java

->Dessin déclarée dans Dessin.java
->Compilation de chaque fichier nécessaire
> javac Rectangle.java

> javac Dessin.java
Produits les fichiers:
Dessin.class
Rectangle.class
Seule la classe contenant main est exécutable

> java Rectangle
Exception in thread « main » java.lang.NoSuchMethodError: main 17
La syntaxe de la déclaration des attributs est la suivante :
type nom_attribut;
Exemple:
Les attributs hauteur et largeur, de type double, de la classe Rectangle

pourront être déclarés par :
18
9
21/02/2017
L’accès aux valeurs des attributs d’une instance de nom nom_instance se fait
comme pour accéder aux champs d’une structure :
nom_instance.nom_attribut;
Exemple:
La valeur de l’attribut hauteur d’une instance rect1 de la classe Rectangle

sera référencée par l’expression : rect1.hauteur
19
L’instruction :
nomClasse instance = new nomClasse();
Crée une instance de type nomClasse et initialise tous ses attributs avec des valeurs
par défaut :
int 0
double 0.0
boolean false
objets null
Exemple:
Rectangle rect = new Rectangle();

20
10
21/02/2017
21
La syntaxe de la définition des méthodes d’une classe est la syntaxe normale

de définition des fonctions :
type_retour nom_methode (type_param1 nom_param1, ….)

{
// corps de la méthode
…..
}
Mais elles sont simplement mises dans la classe elle-même.
Exemple: la méthode surface() de la classe Rectangle :
22
11
21/02/2017
Les attributs d’une classe constituent des variables directement accessibles

dans toutes les méthodes de la classe ( i.e. des variables globales à la classe)
On parle de « protée de classe».
Il n’est donc pas nécessaire de les passer comme arguments des méthodes.
Mais elles sont simplement mises dans la classe elle-même.
23
Les méthodes sont donc :

->des fonctions propres à la classe
->qui ont donc accès aux attributs de la classe
-> il ne faut donc pas passer les attributs comme arguments aux
méthodes de la classe!
Exemple: la méthode surface() de la classe Rectangle :
24
12
21/02/2017
Mais ce n’est pas parce qu’on n’a pas besoin de passer les attributs de la
classe comme arguments aux méthodes de cette classe, que les méthodes
n’ont jamais de paramètres!
Les méthodes peuvent avoir des paramètres : ceux qui sont nécessaires (et
donc extérieurs à l’instance) pour exécuter la méthode en question!
Exemple:
25
L’appel aux méthodes définies pour une instance de nom nomInstance se

fait à l’aide d’expressions de la forme :
nomInstance.nomMethode(valArg1, ….);
Exemple:
la méthode double surface() définie pour la classe Rectangle peut être appelée pour
une instance rect1 de cette classe par : rect1.surface();
26
13
21/02/2017
Chaque instance a ses propres attributs : aucun risque de confusion d’une

instance à une autre
rect1.surface() : méthode surface de la classe Rectangle s’appliquant a rect1

27
Surface()
longueur
largeur
28
14
21/02/2017
Tout ce qu’il n’est pas nécessaire de connaitre à l’extérieur d’un objet devrait
être dans le corps de l’objet et identifié par le mot clé : private
class Rectangle {
private double hauteur;
private double largeur;
}
Attribut d’instance privée = inaccessible depuis l’extérieur de la classe.

C’est également valable pour les méthodes.
Erreur de compilation si référence à un(e) attribut/méthode d’instance privée

error : hauteur has private access in Rectangle
29
À l’inverse, l’interface, qui est accessible de l’extérieur, se déclare avec le mot

clé : public
class Rectangle {
public double surface() {….}
…..
}
Dans la plupart des cas :

Privé:
Tous les attributs
La plupart des méthodes
Public:
Quelques méthodes bien choisies (interface)
30
15
21/02/2017
Les programmes Java sont habituellement organisés au moyen de la notion

de paquetage (package).
Si vous ne spécifiez rien, vous travaillez dans le package par défaut.
Si aucun droit d’accès n’est spécifié, alors l’attribut ou la méthode

publiquement accessible par toutes les autres classes du même package,
mais pas en dehors de celui-ci !
→ il est recommandé de meCre explicitement public devant tout membre

que vous estimez devoir appartenir à l’interface de la classe
31
Tous les attributs sont privés ?
Et si on a besoin des les utiliser depuis l’extérieur de la classe?!
Par exemple, comment « manipuler» la largeur et la hauteur d’un rectangle?
32
16
21/02/2017
Si le programmeur le juge utile, il inclut les méthodes publiques nécessaires…
1. Accesseurs (méthodes « get» ou « getters») :

Retour de la valeur d’une variable d’instance précise
double getHauteur() { return hauteur;}

double getLargeur() { return largeur;}
2. Manipulateurs (méthodes « set » ou « setters »):

Affectation de l’argument à une variable d’instance précise
void setHauteur(double h) { hauteur=h ;}

void setLargeur(double l) { largeur=l ;}
33
34
17
21/02/2017
Fastidieux d’écrire des accesseurs/manipulateurs alors que l’on pourrait tout

laisser en public ?
class Rectangle {
public double largeur;
public double hauteur;
}
Mais dans ce cas …
Rectangle rect = new Rectangle();

rect.hauteur = -36;
35
Masquage = un identificateur cache un autre identificateur
Situation typique en POO : un paramètre cache un attribut
void SetHauteur (double hauteur) {

hauteur=hauteur ;
}
36
18
21/02/2017
Si dans une méthode, un attribut est masqué alors la valeur de l’attribut peut
quand même être référencée a l’aide du mot réservé this.
this est une référence à l’instance courante : this = moi
Syntaxe pour spécifier un attribut en cas d’ambiguïté : this.nomAttribut
Exemple: void SetHauteur (double hauteur) {

this.hauteur=hauteur ;
}
L’utilisation de this est obligatoire dans les situations de masquage
37
Attention : la classe prédéfinie String, les tableaux et les objets,

contrairement aux entités de types élémentaires, sont manipulés via des
références :
Il est impératif de s’en rappeler lorsque l’on :

• Compare deux objets
• Affecte un objet a un autre
• Affiche un objet
38
19
21/02/2017
La constante prédéfinie null peut être affectée à n’importe quel objet de

n’importe quelle classe.
Affectée à une variable, elle indique que celle-ci ne référence aucun objet :
Rectangle rect = null; // la variable rect ne référence aucun objet
39
Partie 1 : les concepts de la POO Constructeurs
Première solution : affecter individuellement une valeur à chaque attribut
Ceci est une mauvaise solution dans le cas général :
• Elle implique que tous les attributs fasse partie de l’interface (public) ou soient
assortis d’un manipulateur → casse l’encapsulation
40
20
21/02/2017
Deuxième solution : définir une méthode dédiée à l’initialisation des attributs
Pour faire ces initialisations, il existe en java des méthodes particulières appelées
constructeurs.
41
Un constructeur est une méthode :

• Invoquée systématiquement lors de la déclaration d’un objet
• Chargée d’effectuer toutes les opérations requises en début de vie de
l’objet (dont l’initialisation des attributs)
Syntaxe de base : Nomclasse (liste_paramètres)

{
/* initialisations des attributs en utilisant
liste_paramètres */
}
Exemple :
42
21
21/02/2017
Les constructeurs sont des méthodes presque comme les autres. Les
différences sont :
• Pas de type de retour (pas même void)
• même nom que la classe
• Invoqués systématiquement à chaque fois qu’une instance est créée.
Comme les autres méthodes :

• Les constructeurs peuvent être surchargés → une classe peut donc
avoir plusieurs constructeurs.
43
La déclaration avec initialisation d’un objet se fait selon la syntaxe suivante:
Syntaxe : NomClasse instance = new NomClasse(valarg1….valargN);

Ou valarg1,….valargN sont les valeurs des arguments du constructeur,
Exemple : Rectangle rect1 = new Rectangle(6.2,8.5); // appel du

//constructeur a deux paramètres.
44
22
21/02/2017
Un constructeur par défaut est un constructeur qui n’a pas de paramètre
Exemple :
// le constructeur par défaut
Rectangle() { hauteur=2.0; largeur=6.0; }
// deuxième constructeur
Rectangle(double l) { hauteur=2.0; largeur=l; }
// troisième constructeur
Rectangle(double h, double l) { hauteur=h; largeur=l; }
45
Si aucun constructeur n’est spécifié, le compilateur génère automatiquement

une version minimale du constructeur par défaut qui initialise les attributs
avec les valeurs par défaut : 0, 0.0 et false pour les types de base et null pour
les objets.
ATTENTION!
Dès qu’au moins un constructeur a été spécifié, ce constructeur par défaut

par défaut n’est plus fourni.
→ Si donc on spécifie un constructeur sans spécifier de constructeur par

défaut, on ne peut plus construire d’objet de cette classe sans les initialiser
explicitement puisqu’il n’y a plus de constructeur par défaut.
46
23
21/02/2017
A:
C:
B:
47
48
24
21/02/2017
Java offre un moyen de créer la copie d’une instance : le constructeur de copie
Rectangle r1 = new Rectangle(13.5 , 15.4);

Rectangle r2 = new Rectangle(r1);
r1 et r2 sont deux instances distinctes mais ayant des mêmes valeurs pour
leurs attributs.
49
Le constructeur de copie permet d’initialiser une instance en copiant les

attributs d’une autre instance du même type.
Syntaxe:
NonClasse(NomClasse autre) {…}
Exemple:
50
25
21/02/2017
• En java, il n’y a pas de constructeur de copie généré automatiquement.

• Le constructeur de copie n’est pas la seule façon de créer une copie

d’objet. Le moyen le plus usuel est d’avoir recours à la méthode clone().

Rectangle r2 = r1.clone();
51
Un objet est en fin de vie lorsque le programme n’en a plus besoin.

→ La référence qui lui est associée n’est plus utilisée nulle part
Exemple:
→ Récupéra<on de la mémoire associé à l’objet.
52
26
21/02/2017
→ Garbage collection = processus qui récupère la mémoire occupée par les

objets qui ne sont plus référencés par aucune variable
• Egalement appelé « ramasse-miettes »

• Nécessaire pour éviter les fuites de mémoire : indisponibilité des
zones mémoires qui ne sont plus utilisées.
→ le garbage collector est lancé régulièrement pendant l’exécution d’un

programme java.
→ De façon générale, le programmeur java n’a pas à libérer explicitement la

la mémoire utilisée.
53
Supposons que l’on souhaite :

• Créer un objet b à partir d’un autre objet a du même type;
• Assurer que a et b soient deux objets distincts en mémoire

Rectangle r2 = r1;
r1 et r2 référencent ici le même objet et non pas deux copies distinctes du

même objet : toute modification via r2 modifiera également r1.
54
27
21/02/2017
Si l’on veut que l’objet référencé par r2 soit une copie distincte de celui
référencé par r1, il ne faut pas utiliser l’opérateur = mais plutôt un
constructeur de copie (ou la méthode clone() ).

55
La portion de code suivante :
Rectangle rect = new Rectangle(13.0 , 5.4);

System.out.println(rect);
Afficherait la valeur de la référence. Par exemple : CA@56c2fff4!
Que faire si l’on souhaite faire afficher le contenu de l’objet en utilisant

exactement le même code?
Java prévoit que vous fournissiez une méthode qui retourne une
représentation de l’instance sous forme d’une String.
→ String toString()
La méthode toString() est invoquée automatiquement par System.out.println
56
28
21/02/2017
Exemple:
affiche : Rectangle 4.0 x 5.0

57
Exemple:
58
29
21/02/2017
L’opérateur == appliqué à deux objets compare les références de ces objets.
Donc que faire si l’on souhaite comparer le contenu de deux objets de type
Rectangle?
Java prévoit que vous puissiez définir la méthode equals(), par exemple avec
l’entête suivant : boolean equals(Rctangle arg)
59
Exemple :
60
30
21/02/2017
Exemple (suite) :
61
Partie 1 : les concepts de la POO Héritage
Oublions un peu les rectangles …
62
31
21/02/2017
Classe Voiture Classe Avion

------------------------ --------------------------
#Marque #Marque
#dateAchat #dateAchat
#Prix #Prix
#Cylindree #Moteur
#nbPortes #heuresVol
------------------------ --------------------------
+voiture +avion
+affiche : void +affiche : void
63
Classe Vehicule
------------------------
#Marque
#dateAchat
#Prix
------------------------
+vehicule
+affiche : void
Classe Voiture Classe Avion

------------------------ --------------------------
#Cylindree #Moteur
#nbPortes #heuresVol
------------------------ --------------------------
+voiture +avion
64
32
21/02/2017
Après les notions d’encapsulation et d’abstraction, le troisième aspect

essentiel de le « POO » est la notion d’héritage.
L’héritage représente la relation « est-un »
Il permet de créer des classes plus spécialisées, appelées sous-classes, à partir

de classes plus générales déjà existantes, appelées super-classes.
65
Lorsqu’une sous-classe c1 est créée à partir d’une super-classe c :
• Le type est hérité : un c1 est (aussi) un c

• c1 va hériter de l’ensemble des attributs et des méthodes de c (sauf les
constructeurs)
→ les aCributs et méthodes de c vont être disponibles pour c1 sans que
l’on ait besoin de les redéfinir explicitement dans c1.
• Par ailleurs :
Des attributs et/ou méthodes supplémentaires peuvent être
définis par la sous-classe c1
→ enrichissement
Des méthodes héritées de c peuvent être redéfinies dans c1

→ spécialisation 66
33
21/02/2017
Lorsqu’une sous-classe c1 (ici Voiture ou Avion) est créée à partir d’une super-
classe c (ici Vehicule) :
• Le type est hérité : une voiture est (aussi) un vehicule

• Voiture va hériter (i.e. recevoir) de l’ensemble des attributs et des
méthodes de Vehicule (sauf les constructeurs)
• Des attributs et/ou des méthodes supplémentaires peuvent être
définis par la sous-classe voiture : nbPortes, cylindree
• Des méthodes héritées de Vehicule peuvent être redéfinies dans
Voiture : affiche().
67
L’héritage permet donc :

• D’expliciter des relations structurelles et sémantique entre classe
• De réduire les redondances de description et de stockage des
propriétés.
Attention !
• L’héritage doit être utilisé pour décrire une relation « est-un »

• Il ne doit jamais décrire une relation « a-un »/ « possède-un »
68
34
21/02/2017
Classe Vehicule
------------------------
#Marque
#dateAchat
#Prix
------------------------
+Vehicule
+affiche : void
Classe Avion
Classe Voiture
--------------------------
------------------------
#Moteur
#nbPortes
#heuresVol
------------------------
--------------------------
+voiture
+Avion
+affiche : void
+affiche : void
Classe Voitureelec
----------------------------
#temps de recharge
----------------------------
+Voitureelec
+affiche : void
69
Par transitivité, les instances d’une sous-classe possèdent :
• Les attributs et méthodes (hors constructeurs) de l’ensemble des

classes parentes (super-classe, super-super-classe, etc.)
Enrichissement par héritage :
• Crée un réseau de dépendances entre classes,

• Ce réseau est organisé en une structure arborescente ou chacun des
nœuds hérite des propriétés de l’ensemble des nœuds du chemin
remontant jusqu’à la racine.
70
35
21/02/2017
Une super-classe :
• Est une classe « parente »
• Déclare les attributs/méthodes communs
• Peut avoir plusieurs sous-classes
Une sous-classe est :
• Une classe « enfant »
• Étend une seule super-classe
• Hérite des attributs, des méthodes et du type de la super-classe
• Un attribut/une méthode hérité(e) peut s’utiliser comme s’il/elle était

déclaré(e) dans la sous-classe au lieu de la super-classe (en fonction des
droits d’accès)
→ on évite ainsi la duplica<on du code

71
Définition d’une sous-classe en Java :
Syntaxe:
Class NomSousClasse extends NomSuperClasse

{
/* Déclaration des attributs et méthodes spécifiques à la sous-classe*/
}
Exemple:
72
36
21/02/2017
Class Vehicule {
//…
}
Class Voiture extends Vehicule

{
private nbPortes;
// …
}
73
Jusqu’à maintenant, l’accès aux membres (attributs et méthodes) d’une classe

pouvait être:
• Soit public : visibilité totale à l’intérieur et à l’extérieur de la classe
(mot-clé public)
• Soit privé : visibilité uniquement à l’intérieur de la classe (mot-clé
private)
• Soit par défaut (aucun modificateur) : visibilité depuis toutes les
classes du même package.
Un troisième type d’accès régit l’accès aux attribut/méthodes au sein d’une

hiérarchie de classes :
• L’accès protégé : assure la visibilité des membres d’une classe dans les
classes de sa descendance et dans les autres classes du même package
(mot-clé protected)
74
37
21/02/2017
• Une sous-classe n’a pas de droit d’accès aux membres (attributs ou

méthodes) privés hérités de ses super-classes
→ elle doit alors utiliser les getters/setters prévus dans la super-classe
• Si une super-classe veut permettre à ses sous-classes d’accéder à un

membre donné, elle doit le déclarer non pas comme privé (private), mais
comme protégé (protected).
Attention : la définition d’attributs protégés perturbe la bonne encapsulation

surtout qu’en Java un membre protégé est aussi accessible par toutes les
classes d’un même package.
→ les attributs protégés sont d’un usage peu recommandé en Java.
75
Le niveau d’accès protégé correspond à une extension du niveau privé

permettant l’accès aux sous-classes et aux autres classes du même package.
Exemple:
Class Vehicule {
//…
protected double vitesse;
}
Class Voiture extends Vehicule{

// …
public void controleVitesse( ){
if (vitesse > 60) { //… }
} 76
}
38
21/02/2017
• Membres publics : accessibles pour les programmeurs utilisateurs de la

classe.
• Membres protégés : accessibles aux programmeurs d’extensions par

héritage de la classe ou travaillant dans le même package.
• Membres privés : pour le programmeur de la classe → structure interne.
77
Classe Vehicule
------------------------
#Marque
#dateAchat
#Prix
------------------------
+Vehicule
+affiche : void
Classe Avion
Classe Voiture
--------------------------
------------------------
#Moteur
#nbPortes
#heuresVol
------------------------
--------------------------
+voiture
+Avion
+affiche : void
+affiche : void
Classe Voitureelec
----------------------------
#temps de recharge
----------------------------
+Voitureelec
+affiche : void
78
39
21/02/2017
Masquage : pour les variables (shadowing)

Redéfinition : pour les méthodes (overriding)
• Masquage : un identificateur qui en cache un autre.
• Redéfinition : une méthode déjà définie dans une super-classe a une

nouvelle définition dans une sous-classe.
• Situations possibles dans une hiérarchie :
Même nom d’attribut ou de méthode utilisé sur plusieurs niveaux

Peu courant pour les attributs
Très courant et pratique pour les méthodes
79
La méthode affiche de la classe Voiture redéfinit celle de Vehicule
• Un objet de type Voiture n’utilisera donc jamais la méthode affiche de la

classe Vehicule.
• Vocabulaire Orienté Objet :
Méthode héritée = méthode générale, méthode par défaut

Méthode qui redéfinit la méthode héritée = méthode spécialisée
80
40
21/02/2017
Il est parfois souhaitable d’accéder à une méthode / un attribut masqué(e).
Donc pour accéder aux attributs masqués et aux méthodes redéfinies de la

super-classe :
• On utilise le mot réservé super

• Syntaxe : super.méthode ou attribut
• Exemple :
Class Voiture extends Vehicule{

// …
public void affiche( ){
super.affiche();
// affichage des autres attributs
} 81
}
Lors de l’instanciation d’une sous-classe, il faut initialiser :

• Les attributs propres à la sous-classe
• Les attributs hérités des super-classes
Mais …
Il ne doit pas être à la charge du concepteur des sous-classes de réaliser lui-
même l’initialisation des attributs hérités
L’accès à ces attributs pourrait notamment être interdit! (private)
L’initialisation des attributs hérités doit donc se faire au niveau des classes ou
ils sont explicitement définis.
Solution : l’initialisation des attributs hérités doit se faire en invoquant les

constructeurs des super-classes. 82
41
21/02/2017
L’invocation du constructeur de la super-classe se fait au tout début du corps

du constructeur au moyen du mot réservé super.
Syntaxe :
SousClasse ( liste de paramètres )

{
super(arguments);
// initialisation des attributs de la SousClasse ici
}
Lorsque la super-classe admet un constructeur par défaut, l’invocation
explicite de ce constructeur dans la sous-classe n’est pas obligatoire.
→ le compilateur se charge de réaliser l’invoca<on du constructeur par défaut.

83
Si la classe parente n’admet pas de constructeur par défaut, l’invocation

explicite d’un de ses constructeurs est obligatoire dans les constructeurs de la
sous classe.
→ la sous-classe doit admettre au moins un constructeur explicite
Exemple :
84
42
21/02/2017
Un autre exemple : (qui ne fait pas la même chose)
85
Il n’est pas nécessaires d’avoir des attributs supplémentaires dans la sous-

classe.
86
43
21/02/2017
Chaque constructeur d’une sous-classe doit appeler super(…)
Les arguments fournis à super doivent être ceux d’au moins un des
constructeurs de la super-classe.
L’appel doit être la toute 1er instruction
Erreur si l’appel vient plus tard ou 2 fois
Aucune autre méthode ne peut appeler super(…)
87
Et si l’on oublie l’appel à super(…) ?

Appel automatique à super() si le constructeur par défaut existe
Pratique parfois, mais erreur si le constructeur par défaut n’existe pas
Pour éviter des problèmes avec les hiérarchies de classes, dans un

premier temps :
Toujours déclarer au moins un constructeur
Toujours faire l’appel à super(…)
88
44
21/02/2017
89
Partie 1 : les concepts de la POO Polymorphisme
C’est un concept puissant de la POO qui complète l’héritage
Le polymorphisme est le faite qu’un objet puisse s’adapté

automatiquement au type des données auxquels il s’applique.
Plus précisément, quand une même méthode est définie à la fois dans la
classe mère et dans la classe fille, son exécution est réalisée en fonction de
l’objet associé à l’appel
90
45
21/02/2017
Considérons cette situation dans laquelle les classes Point et Poincol sont
censées disposer chacune d’une méthode affiche()
class Point {
public Point(int x, int y){…}
public void affiche() {…}
}
Class Pointcol extends Point {

public Pointcol(int x, int y, byte couleur){…}
public void affiche() {…}
}
91
Avec ces instructions :
Point p;
p = new Point(3,5);
On aboutit tout naturellement à cette situation :
92
46
21/02/2017
Mais il se trouve que Java autorise ce genre d’affectation (p est toujours de

type Point !)
p = new Pointcol(3,5, (byte)2);
La situation correspondante est :
Java permet d’affecter à une variable objet non seulement la référence à un

objet du type correspondant, mais aussi une référence à un objet d’un type
dérivé
93
Considérons maintenant ces instructions :
Point p = new Point(3,5);

p.affiche(); //appelle la méthode affiche de la classe Point
p = new Pointcol(4,8,2);
p.affiche(); //appelle la méthode affiche de la classe Pointcol
• Dans la dernière instruction, p est de type Point, alors que l’objet

référencé par p est de type Pointcol
• p.affiche appelle alors la méthode affiche de la classe Pointcol
→Java ne se fonde pas sur le type de la variable p mais bel et bien sur le
type effectif de l’objet référencé au moment de l’appel.
94
47
21/02/2017
Résolution dynamique des liens
Ce choix d’une méthode au moment de l’exécution porte le nom de résolution

dynamique des liens.
En résumé
Le polymorphisme en Java se traduit par :
• La compatibilité par affectation entre un type de classe et un type

ascendant
• La résolution dynamique des méthodes
95
Animal[] animaux=new Animal[4] // Déclare un tableau de type animal
animaux[0]= new Chien();

animaux[1]= new Chat();
animaux[2]= new Loup(); / * On peut placer un objet de n’importe quelle sous-
animaux[4]= new Lion(); classe d’Animal dans le tableau */
for ( int i=0; i<animaux.length; i++) {

animaux[i].manger(); //Java saura faire la différence
}
96
48
21/02/2017
Bien utilisé, le polymorphisme évite les codes qui comportent de

nombreux embranchements et tests.
sans polymorphisme, la méthode manger() aurait dû s’écrire :
for (int i=0; i < animaux.length; i++) {

if (animaux[i] instanceof Chien) {
. . . // le chien mange
}
else if (animaux[i] instanceof Chat) {
. . . // le chat mange
}
…
}
97
Le polymorphisme facilite l’extension des programmes :

on peut créer de nouvelles sous-classes sans toucher aux
programmes déjà écrits
Par exemple, si on ajoute une classe Gazelle, le code de manger() sera

toujours valable
Sans polymorphisme, il aurait fallu modifier le code source pour ajouter

un nouveau test :
if (animaux[i] instanceof Gazelle) {

… // la Gazelle mange
}
98
49
21/02/2017
Au sommet d’une hiérarchie de classe, il n’est pas toujours possible de :
Donner une définition générale de certaines méthodes, compatibles

avec toutes les sous-classes,
… même si l’on sait que toutes ces sous-classes vont effectivement

implémenter ces méthodes.
99
Exemple:
Définir surface() de façon arbitraire sachant qu’on va la redéfinir plus tard

n’est pas une bonne solution (source d’erreurs).
→ Solu<on : déclarer la méthode surface() comme abstraite
100
50
21/02/2017
Si l’on ne met aucune méthode surface() dans la classe Figure, la classe

Dessin ne compile pas
→ On doit donc mettre une méthode surface() dans la classe Figure
De plus, on aimerait :
→ imposer aux sous-classes (Rectangle, Cercle…) d’avoir leur méthode
surface() spécifique.
101
Mais comment faire si on sait pas comment calculer la surface d’une Figure
générique?
Et de plus…
Comment imposer a cette méthode surface soit redéfinie dans les sous-
classes?
102
51
21/02/2017
Première solution :
Ajouter une méthode quelconque définie arbitrairement :
C’est une très mauvaise idée
→ Mauvaise modèle de la réalité (calcule incorrect de la surface si une sous-

classe ne redéfinit pas la méthode).
→ cette solution n’impose pas que la méthode surface() soit redéfinie
103
Bonne solution :
Signaler que la méthode doit exister dans chaque sous-classe sans qu’il soit
nécessaire de la définir dans la super-classe.
→ Déclarer la méthode comme abstraite
104
52
21/02/2017
Une méthode abstraite, est incomplètement spécifiée:

Elle n’a pas de définition dans la classe ou elle est introduite (pas de
corps)
Elle sert a imposer aux sous-classes (non abstraites) qu’elles doivent
définir la méthode abstraite héritée
Elle doit être contenue dans une classe abstraite
Syntaxe:
abstract Type nom_methode (liste d’arguments);
Exemple:
105
Une classe abstraite est une classe au moyen du mot réservé abstract:
Elle ne peut être instanciée

Ses sous-classes restent abstraites tant qu’elles ne fournissent pas
les définitions de toutes les méthodes abstraites dont elles héritent.
Un exemple concret…
106
53
21/02/2017
Cercle n’est une classe abstraite Rectangle reste par contre une
classe abstraite
107
Ce modificateur permet d’indiquer les éléments du programme qui ne

doivent pas être modifiés/redéfinis/étendus
Possible pour les classes, méthodes, attributs et variables

Utile surtout pour les variables
Moins courant pour les méthodes et les classes
108
54
21/02/2017
Si l’on ajoute final à une méthode :
→ impossible de la redéfinir dans une sous-classe
→ message d’erreur du compilateur si par exemple la classe Cercle essaie de

redéfinir la méthode afficheNbrFigure()
109
Si l’on ajoute final à une classe :
→ impossible d’étendre la classe par une sous-classe
Exemple: si on aimerait que la classe Rectangle n’ait jamais de sous-classe
110
55
21/02/2017
Si l’on ajoute final à une variable d’instance, une variable locale ou un

paramètre :
→ il devient impossible de lui affecter une valeur plus d’une fois
Un attribut final peut être initialisé dans le constructeur mais ne doit plus être
modifié par la suite.
Attention: final empêche l’affectation d’une nouvelle valeur à une variable,

mais n’empêche pas de modifier l’éventuel objet référencé par cette variable.
Un exemple …
111
112
56
21/02/2017
Partie 1 : les concepts de la POO Interfaces
S’utilise pour les variables et les méthodes
Si on ajoute static à la déclaration d’une variable :
La valeur de la variable est partagée entre toutes les instances de la

classe
Pas possible pour les variables locales
Si on ajoute static à une méthode :
On peut appeler la méthode sans construire d’objet
113
Variable d’instance:
Réservation d’une zone pour chaque objet construit avec new

Résultat : chaque objet a sa propre zone/valeur pour la variable
d’instance
Variable de classe (statique) :
Déclaration précédée par static

Réservation d’une zone lors du chargement de la classe
Aucune zone réservée quand un nouveau objet est construit avec
new
Résultat : tous les objets se réfèrent à la même zone/valeur pour la
variable de classe
114
57
21/02/2017
115
Modification d’une variable d’instance:

La valeur change seulement pour l’objet actuel
Modification d’une variable de classe:

La valeur change pour tous les objets de la classe
A quoi sert une variable static?
→ Représentation d’une valeur qui est commune à tous les objets de la

classe
Exemple:
Intégrons à une classe Employe le fait que 63 ans est l'âge officiel de départ
à la retraite.
116
58
21/02/2017
Similairement, si l’on ajoute static à une méthode on peut alors y accéder sans
aucun objet.
117
Puisqu’une méthode statique peut être appelée avec ou sans objet:
le compilateur ne peut pas être sur que l’objet this existe pendant
l’exécution de la méthode
Il ne peut donc pas admettre l’accès aux variables/méthodes d’instance
(car elles dépendent de this)
Conclusion pour les accès dans la même classe :
→ une méthode sta<que peut seulement accéder à d’autres méthodes

statiques et à des variables statiques de la classe.
118
59
21/02/2017
119
Exemples de méthodes statiques:

Math.sqrt
La méthode main
La méthode main a un entête fixe: public static void main(String[] args)
Puisque la méthode main est obligatoirement statique :

Elle ne peut pas accéder à des variables/méthodes d’instance
Elle peut seulement accéder à des variables/méthodes statiques
En dehors de cela, la classe de la méthode main est comme n’importe quelle

classe.
Elle peut avoir des constructeurs, des méthodes et des variables.
120
60
21/02/2017
Problème : java ne permet que l’héritage simple → chaque sous-classe ne

peut avoir qu’une seule classe parente directe !
Mais en fait, pourquoi nous souhaitons utiliser de l’héritage multiple?

→ le besoin d’imposer à certaines classes de meCre en œuvre des
méthodes communes
→ imposer un contenu commun à des sous-classes en dehors d’une relation

d’héritage est le rôle joué par la notion d’interface en java.
121
Syntaxe :
interface UneInterface { constantes ou méthodes abstraites }
Exemple :
// toute méthode déclarer dans une

// interface est nécessairement
// abstraite et public.
// public final static pour les constantes.
Il ne peut y avoir de constructeur dans une interface

→ impossible de faire new !
122
61
21/02/2017
Comment établir le lien entre une interface et une classe?

Syntaxe :
classe UneClasse implements interface1, interface2, … ,interface N { …}
Exemple :
123
Une interface est un moyen d’attribuer des composants communs à des

classes non-liées par une relation d’héritage :
→ ses composants seront disponibles dans chaque classe qui l’implémente
Composants possibles :
1. Variables statiques finales (assez rare)

Ambiguïté possible, nom unique exigé
2. Méthodes abstraites (courant)

Chaque classe qui implémente l’interface sera obligée
d’implémenter chaque méthode abstraite déclarée dans l’interface
si elle veut pouvoir être instanciée.
Une façon de garantir que certaines classes ont certaines
méthodes, sans passer par des classes abstraites.
124
62

CoursLicencePOO2017 PDF

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

CoursLicencePOO2017 PDF

Загружено:

Авторское право:

Доступные форматы

21/02/2017

Université Hassan II - Casablanca

PROGRAMMATION MULTIMEDIA MOBILE

Partie 1 : les concepts de la programmation orientée objet (en java)

Mohammed Amine NOUA

Mohammed Amine NOUA Partie 1 : les concepts de la POO

Mohammed Amine NOUA Partie 1 : les concepts de la POO

Partie 1 : les concepts de la POO Introduction

Partie 1 : les concepts de la POO Introduction

Partie 1 : les concepts de la POO Introduction

Un des objectifs principaux de la notion d’objet:

Organiser des programmes complexes grâce aux notions:

Partie 1 : les concepts de la POO Encapsulation & abstraction

• Attributs : les données incluses dans un objet

Les objets sont définis par leurs attributs et leurs méthodes.

Partie 1 : les concepts de la POO Encapsulation & abstraction

Le processus d’abstraction consiste à identifier pour un ensemble

• Des caractéristiques communes à tous les éléments

→ se focaliser sur l’essen<el, cacher les détails.

Partie 1 : les concepts de la POO Encapsulation & abstraction

L’interface d’une voiture :

• Volant, accélérateur, pédale de frein, etc.

→ abstrac<on de la no<on de voiture (en tant qu’objet à conduire)

Partie 1 : les concepts de la POO Encapsulation & abstraction

En plus du regroupement des données et des traitements relatifs à une

• Niveau externe : partie visible par les programmeurs-utilisateurs :

• Niveau interne : détails d’implémentation :

Partie 1 : les concepts de la POO Encapsulation & abstraction

Partie 1 : les concepts de la POO Encapsulation & abstraction

Partie 11: :les

Partie 1 : les concepts de la POO Encapsulation & abstraction

Partie 1 : les concepts de la POO Classes, objets, attributs et méthodes

• Le résultat des processus d’encapsulation

Partie 1 : les concepts de la POO Classes, objets, attributs et méthodes

En java une classe se déclare par le mot-clé class.

Exemple : class Rectangle { …}

Ceci définit un nouveau type du langage.

La déclaration d’une instance d’une classe se fait de façon similaire à la

Rectangle rect1; // déclare une instance rect1 de la classe Rectangle.

Partie 1 : les concepts de la POO Classes, objets, attributs et méthodes

1. Déclaration de plusieurs classes dans le même fichier : la classe Rectangle

> javac Dessin.java

Produit les fichiers:

Le compilateur crée un fichier .class

Partie 1 : les concepts de la POO Classes, objets, attributs et méthodes

2. Déclaration de chaque classes dans un fichier à part :

->Rectangle déclarée dans Rectangle.java

> javac Rectangle.java

Seule la classe contenant main est exécutable

Partie 1 : les concepts de la POO Classes, objets, attributs et méthodes

La syntaxe de la déclaration des attributs est la suivante :

Les attributs hauteur et largeur, de type double, de la classe Rectangle

Partie 1 : les concepts de la POO Classes, objets, attributs et méthodes

La valeur de l’attribut hauteur d’une instance rect1 de la classe Rectangle

Partie 1 : les concepts de la POO Classes, objets, attributs et méthodes

nomClasse instance = new nomClasse();

Rectangle rect = new Rectangle();

Partie 1 : les concepts de la POO Classes, objets, attributs et méthodes

Partie 1 : les concepts de la POO Classes, objets, attributs et méthodes

La syntaxe de la définition des méthodes d’une classe est la syntaxe normale

type_retour nom_methode (type_param1 nom_param1, ….)

Exemple: la méthode surface() de la classe Rectangle :

Partie 1 : les concepts de la POO Classes, objets, attributs et méthodes