Upload
dione-barthelemy
View
104
Download
2
Embed Size (px)
Citation preview
1
Cours JAVA / Y.Laborde
Java : un langage Orienté Objet
LES CONCEPTS de L’ORIENTE OBJET :
L’encapsulation : introduction au concept de classe introduction au concept d’objet
Le protocole de communication : L’envoi de messages (le mode inter-objets) L’envoi de messages (le mode intra-objet)
L’encapsulation contrôlée : la notion de « package » les spécificateurs d’accès aux classes et à leurs instances les spécificateurs d’accès aux champs des objets le bon usage de l’encapsulation à accès contrôlé
2
Cours JAVA / Y.Laborde
Java : un langage Orienté Objet
LES CONCEPTS de L’ORIENTE OBJET :
L’encapsulation : introduction au concept de classe
3
Cours JAVA / Y.Laborde
Comment, dans cette famille, exprime-t-on l’algorithmique ?
L’encapsulation [introduction au concept de classe]
Qu’y avait-il avant l’objet ?
Principalement, les « langages structurés et procéduraux »
Nous resterons dans la famille des « langages impératifs » (soit celle qui s’impose majoritairement en développement)Dans cette famille, l’algorithmique s’exprime par des ordres séquentiels d’exécution des instructions d’un programme.
Fais ceci ; Fais cela ;puis
etc.
Principalement, les « langages structurés et procéduraux »
4
Cours JAVA / Y.Laborde
L’encapsulation [introduction au concept de classe]
Qu’y avait-il avant l’objet ?
Principalement, les « langages structurés et procéduraux »
// fichier d’entête : Domino.h
#ifndef _domino
#def _domino
// structure Domino
typedef struct {
int m1 ; // marqueDroite
int m2 ; // marqueGauche
} Domino ;
#endif
// fichier de procédures : Domino.c
#include "domino.h" ;
// Fonction estDouble :
boolean estDouble (Domino *d)
{ return d->m1 = = d->m2 ; }
// Fonction main :
int main (void)
{fais ceci; fais cela ; …}
2. Nom du nouveau type
1. Déclaration et définition d’un type
3. Exemple de fonction spécialisée sur le type
5
Cours JAVA / Y.Laborde
L’encapsulation [introduction au concept de classe]
Qu’y avait-il avant l’objet ?
Principalement, les « langages structurés et procéduraux »
Examinons une version plus réaliste d’un programme écrit dans un tel langage
[ Struct S1 ] …
D’un côté, on définit toutes les structures de données utilisées par le programme :
DATA (*.h)
[ Fun F1 ] [ Fun F2 ] …
De l’autre, on définit toutes les fonctionnalités nécessaires :
CODE (*.c)
1. Module regroupant ce qui se rapporte aux dominos
2. Module regroupant ce qui se rapporte aux joueurs
[ Struct S2 ] [ Struct S3 ] [ Struct SN ]
[ Fun F3 ] [ FunFM ]
3. La programmation modulaire fait virtuellement apparaître des entités entre lesquelles des communications sont établies
6
Cours JAVA / Y.Laborde
L’encapsulation [introduction au concept de classe]
Quel principal changement l’Orienté Objet apporte-t-il ?
Il opère d’une manière effective ce que les techniques de programmation modulaire n’effectuent que virtuellement en procédant à
l’encapsulation dans une même entité des DATA et du CODE
DATA
CODE
[ Struct S1 ]
[ Fun F1 ]
[ Fun F2 ]
[ Struct S2 ]
[ Fun F3 ]
[ Struct S3 ]
…
CLASSE
chaque entité est appelée une CLASSE
La classe Domino La classe Joueur Chaque classe répond aux 3 caractéristiques d’un type :
1. Le nom du type (la classe)
2. Les données du type (les data)
3. Les fonctionnalités capables d’opérer sur des valeurs du type (les fonctions et leurs codes)
int m1 ;
int m2 ;
boolean estDouble () {fais ceci ; fais cela ; …}
Domino retourné ( ) {fais ceci ; fais cela ; …}
7
Cours JAVA / Y.Laborde
// Fonction estDouble : Boolean estDouble (Domino *d) { return d->m1 = = d->m2 ; } // Fonction retourné : Domino* retourné (Domino *d) { int m = d->m1 ; // échange d->m1 = d-> m2 ; // des marques d->m2 = m ; // du domino return d ; }
// structure Dominotypedef struct {
int m1 ; // marqueDroiteint m2 ; // marqueGauche
} Domino ;
L’encapsulation [introduction au concept de classe]
Quel principal changement l’Orienté Objet apporte-t-il ?
L’Orienté Objet transforme :
la notion de type => en une notion de classetraditionnellement définie encapsulant tout ce qui a trait
de façon éparse au type correspondant
// structure Dominotypedef struct {
int m1 ; // marqueDroiteint m2 ; // marqueGauche
} Domino ;
// Fonction estDouble : Boolean estDouble (Domino *d) { return d->m1 = = d->m2 ; } // Fonction retourné : Domino* retourné (Domino *d) { int m = d->m1 ; // échange d->m1 = d-> m2 ; // des marques d->m2 = m ; // du domino return d ; }
// structure Dominotypedef struct {
int m1 ; // marqueDroiteint m2 ; // marqueGauche
} Domino ;
// structure Dominotypedef struct {
int m1 ; // marqueDroiteint m2 ; // marqueGauche
} Domino ;
// structure Dominotypedef struct {
int m1 ; // marqueDroiteint m2 ; // marqueGauche
} Domino ;
// Fonction estDouble : Boolean estDouble (Domino *d) { return d->m1 = = d->m2 ; } // Fonction retourné : Domino* retourné (Domino *d) { int m = d->m1 ; // échange d->m1 = d-> m2 ; // des marques d->m2 = m ; // du domino return d ; }
// structure Dominotypedef struct {
int m1 ; // marqueDroiteint m2 ; // marqueGauche
} Domino ;
// Fonction estDouble : Boolean estDouble (Domino *d) { return d->m1 = = d->m2 ; } // Fonction retourné : Domino* retourné (Domino *d) { int m = d->m1 ; // échange d->m1 = d-> m2 ; // des marques d->m2 = m ; // du domino return d ; }
// Fonction estDouble : Boolean estDouble (Domino *d) { return d->m1 = = d->m2 ; } // Fonction retourné : Domino* retourné (Domino *d) { int m = d->m1 ; // échange d->m1 = d-> m2 ; // des marques d->m2 = m ; // du domino return d ; }
// La classe Dominoclass {
}
Domino
// La classe Dominoclass Domino {
int m1 ; // marque Droite du dominoint m2 ; // marque Gauche du domino
}
// La classe Dominoclass Domino {
int m1 ; // marque Droite du dominoint m2 ; // marque Gauche du domino
// Fonction estDouble :boolean estDouble ( )
{ return m1 == m2 ; }
}
// La classe Dominoclass Domino {
int m1 ; // marque Droite du dominoint m2 ; // marque Gauche du domino
// Fonction estDouble :boolean estDouble ( )
{ return m1 == m2 ; }
// Fonction retourné :Domino retourné ( )
{ int m = m1 ; // échangem1 = m2 ; // des marquesm2 = m ; // du dominoreturn this ;
} }
8
Cours JAVA / Y.Laborde
mais cela ne va pas sans conséquences :
L’encapsulation [introduction au concept de classe]
Quel principal changement l’Orienté Objet apporte-t-il ?
L’Orienté Objet transforme :
la notion de type => en une notion de classe
// structure Dominotypedef struct {
int m1 ; // marqueDroiteint m2 ; // marqueGauche
} Domino ;
// Fonction estDouble : Boolean estDouble (Domino *d) { return d->m1 = = d->m2 ; } // Fonction retourné : Domino* retourné (Domino *d) { int m = d->m1 ; // échange d->m1 = d-> m2 ; // des marques d->m2 = m ; // du domino return d ; }
// La classe Dominoclass Domino {
int m1 ; // marque Droite du dominoint m2 ; // marque Gauche du domino
// Fonction estDouble :boolean estDouble ( )
{ return m1 == m2 ; }
// Fonction retourné :Domino retourné ( )
{ int m = m1 ; // échangem1 = m2 ; // des marquesm2 = m ; // du dominoreturn this ;
} }
// La classe Dominoclass Domino {
int m1 ; // marque Droite du dominoint m2 ; // marque Gauche du domino
// Fonction estDouble :boolean estDouble ( )
{ return m1 == m2 ; }
// Fonction retourné :Domino retourné ( )
{ int m = m1 ; // échangem1 = m2 ; // des marquesm2 = m ; // du dominoreturn this ;
} }
2. La structure de donnée est déclarée identiquement mais à l’intérieur de la classe
3. Les fonctions ne nécessitent plus de paramètre fournissant une référence à la structure de donnée
4. Les fonctions accèdent directement aux champsde la structure de données (en lecture ou écriture)
5. Une référence spéciale « this » équivaut à l’objet sur lequel la fonction est en train de travailler
1. La classe joue simultanément le rôle d’unestructure de données et d’une structure fonctionnelle
9
Cours JAVA / Y.Laborde
Java : un langage Orienté Objet
LES CONCEPTS de L’ORIENTE OBJET :
introduction au concept d’objet
L’encapsulation : introduction au concept de classe
10
Cours JAVA / Y.Laborde
L’encapsulation [introduction au concept d’objet]
Comment, partant d’un type, générer des « valeurs du type » ?Cela nécessite l’emploi d’une opération spécialeappelée « opération d’instanciation »
// structure Dominotypedef struct {
int m1 ; // marqueDroiteint m2 ; // marqueGauche
} Domino ;
// depuis la fonction main par exemple int main (void) {
Domino d = { m1=1; m2=2 } ;int i = 33 ;
… }
Les variables d et i sont des « valeurs d’un type ».
Elles ont été obtenues par instanciations.L’ « opération d’instanciation » réalise 2 tâches :
1. l’allocation (en terme d’espace) d’une partie de mémoire
2. l’initiation (en terme de valeur) de cet espace mémoire
Mémoire basse
Mémoire haute| | | | | | | | | | | | | | | | |
// depuis la fonction main par exemple int main (void) {
Domino d = { m1=1; m2=2 } ;int i = 33 ;
… }
instanciation du domino d
Valeur de m1 :
int = 1
Valeur de m2 :
int = 2
// depuis la fonction main par exemple int main (void) {
Domino d = { m1=1; m2=2 } ;int i = 33 ;
… }
Valeur de i :int = 33
instanciation de l’entier i
// depuis la fonction main par exemple int main (void) {
Domino d = { m1=1; m2=2 } ;int i = 33 ;
… }
11
Cours JAVA / Y.Laborde
L’encapsulation [introduction au concept d’objet]
Comment, partant d’une classe, générer des « objets » ?De la même manière, on réalisera une « instanciation »
class Domino { // La classe Dominoint m1 ; // marqueDroiteint m2 ; // marqueGauche
// un CONSTRUCTEUR de dominopublic Domino ( int vm1 , int vm2 )
{ m1 = vm1 ; m2 = vm2 ; }}
La variable d estun « objet » de classe Domino.
Il a été obtenu par instanciation.
L’ « opération d’instanciation » réalise 2 tâches : (en première approximation)
1. l’allocation de l’espace mémoire (invoquée par l’opérateur « new »)
2. l’initialisation de l’espace mémoire (par appel au constructeur)
Mémoire basse
Mémoire haute| | | | | | | | | | | | | | | | |
class MonAppli { // depuis une classe …
// … qui contient la fonction main public static int main (String[] args) {
Domino d = new Domino ( 1, 2 ) ;
… }}
class MonAppli { // depuis une classe …
// … qui contient la fonction main public static int main (String[] args) {
Domino d = new Domino ( 1, 2 ) ;
… }}
instanciation du domino d
class Domino { // La classe Dominoint m1 ; // marqueDroiteint m2 ; // marqueGauche
// un CONSTRUCTEUR de dominopublic Domino ( int vm1 , int vm2 )
{ m1 = vm1 ; m2 = vm2 ; }}
Valeur de m1 :
int = 1
Valeur de m2 :
int = 2
class Domino { // La classe Dominoint m1 ; // marqueDroiteint m2 ; // marqueGauche
// un CONSTRUCTEUR de dominopublic Domino ( int vm1 , int vm2 )
{ m1 = vm1 ; m2 = vm2 ; }}
class MonAppli { // depuis une classe …
// … qui contient la fonction main public static int main (String[] args) {
Domino d = new Domino ( 1, 2 ) ;
… }}
12
Cours JAVA / Y.Laborde
L’encapsulation [introduction au concept d’objet]
// La classe Dominoclass Domino {
int m1 ; // marqueDroiteint m2 ; // marqueGauche
// CONSTEUR de domino à 2 argumentspublic Domino ( int vm1 , int vm2 )
{ m1 = vm1 ; m2 = vm2 ; }
// CONSTEUR de domino à 1 argumentpublic Domino ( int vm )
{ m1 = vm ; m2 = vm ; }
// CONSTEUR de domino PAR DEFAUTpublic Domino ( )
{ m1 = 0 ; m2 = 0 ; }}
class MonAppli { // depuis une classe …
// … qui contient la fonction main public static int main (String[] args) {
// construction du domino [1:2]Domino d2 = new Domino ( 1, 2 ) ;
// construction du domino [3:3]Domino d1 = new Domino ( 3 ) ;
// construction du domino [0:0]Domino d0 = new Domino ( ) ;
}}
Une classe peut accepter plusieurs « constructeurs d’objets »Ils se différencient obligatoirement par leurs listes de paramètres
Chaque constructeur initialise l’objet selon son rôle.
Par exemple, le constructeur à un argument sert pour former un double.
Le rôle des constructeurs est double : (il est de la responsabilité du programmeur)
1. faire en sorte d’initialiser toutes les données de l’objet 2. faire en sorte d’assurer la cohérence interne de l’objet
13
Cours JAVA / Y.Laborde
L’encapsulation [introduction au concept d’objet]
Chaque classe peut construire un ou plusieurs « objets ».Ces objets sont des instances de la même classe. (exemple: d0, d1 et d2 de la diapo précédente) mais
chacun porte ses propres valeurs (ici, m1 et m2) des variables définies dans la classe.
Pour accéder à ces objets, les programmes doivent impérativement utiliser une « référence » ou un « OID » ( pour
Object IDentifier).=> Cette référence est ce que retourne l’opérateur new => Elle est unique et constante tout au long de la vie de l’objet ; la vie de l’objet en dépend=> Un programme peut très bien dupliquer une même référence et la conserver dans
différentes variables objets,la durée de vie de l’objet est alors déterminée par celle de la dernière référence conservée par le programmePar exemple :
public static int main ( String[] args )
{ Domino d1 = new Domino (1,2) ;
{ Domino d2 = d1 ;
{ Domino d3 = d2 ;
d1 = null ; }
}
}
{ ICI : la fonction possède ………………….… 1 référence
{ ICI : la fonction possède …………….… 2 références
{ICI : la fonction possède ………… 3 références
…} ICI : la fonction possède ……... 1 référence
} ICI : la fonction possède …………….… 0 référence
} ICI : la fonction possède ……………….…… 0 référence
… sur ledominoconstruit
La valeur null indique que la variable d1 ne
référencera plus un objet
14
Cours JAVA / Y.Laborde
L’encapsulation [introduction au concept d’objet]
public static int main ( String[] args )
{ Domino d1 = new Domino (1,2) ; Domino d2 = new Domino (3) ; Domino d3 = new Domino (4,5) ; (C:) trois dominos ont été construits
---------------------------------------------------------------------------------------------------------------------------------------------------------------------
d3 = d1 ; (D:) d3 et d1 sont un seul et même
objet !---------------------------------------------------------------------------------------------------------------------------------------------------------------------
(E:) le domino (4,5) n’est plus référencé nulle part ! Il peut donc être détruit !
---------------------------------------------------------------------------------------------------------------------------------------------------------------------
Domino d4 = new Domino (1,2) ; d4 et d1 sont des objets distincts !
---------------------------------------------------------------------------------------------------------------------------------------------------------------------
d1 = null ; d1 ne référence plus aucun objet !
le premier domino (1,2) est toujours référencé par d3 ! Il ne sera doncpas détruit !
}
La classe Domino
int m1, m2 ;
m1= 1
m2= 2
m1= 3
m2= 3
m1= 4
m2= 5
m1= 1
m2= 2
d1
d2 d3
d4
d3
null
Les références ou OID : construction, duplication ou extinction
DUPLICATION :DUPLICATION :Une référence peut être dupliquée par simple affectation
EXTINCTION :EXTINCTION :Lorsque la dernière référence d’un objet est perdue,ce dernier n’est plus accessible ; l’objet peut être détruit.
CONSTRUCTION :CONSTRUCTION :Une nouvelle référence est créée à chaque instanciationpar l’opérateur new suivi d’un constructeur
15
Cours JAVA / Y.Laborde
Terminologie de l’Orienté Objet (1)
Une classe est un modèle contenant une description structurelle et fonctionnelle telle que les fonctions sont capables d’agir sur les structures tout en assurant leur cohérence.
Un objet (ou instance) est une entité construite (instanciée) sur la base d’une classe. Il possède des caractéristiques structurelle et fonctionnelles calquées sur sa classe d’appartenance.
CLASSE :CLASSE :
OBJET ou INSTANCE :OBJET ou INSTANCE :
MMTHODE D’INSTANCE :THODE D’INSTANCE :
VARIABLE D’INSTANCE :VARIABLE D’INSTANCE :en NOM :en NOM :
en VALEUR :en VALEUR :
TAT :TAT :
Les objets d’une même classe :
- partagent les caractéristiques fonctionnelles décrites dans leur classe d’appartenance. On les nomme « méthodes d’instance »
- partagent les noms des caractéristiques structurelles de leur classe, appelées « variables d’état » ou « variables d’instances »- possèdent chacun leurs propres valeurs liées aux variables d’état
L’ensemble des valeurs des variables d’état est appelé l’« état » de l’objet.
ex: la classe Dominoex: la classe Domino
ex: d1 = new Domino ( 3,6 )ex: d1 = new Domino ( 3,6 )
ex: boolean estDouble ( ) {…}ex: boolean estDouble ( ) {…}
ex: un domino : int m1 ;ex: un domino : int m1 ;
ex: pour le domino d1, m1 = 3ex: pour le domino d1, m1 = 3
ex: état du domino d1 : (3,6)ex: état du domino d1 : (3,6)
16
Cours JAVA / Y.Laborde
Terminologie de l’Orienté Objet (2)
OPOPRATEURRATEUR
D’INSTANCIATION :D’INSTANCIATION :
RRFFRENCE ou OID :RENCE ou OID :
CONSTRUCTEUR :CONSTRUCTEUR :
La seule méthode pour créer un objet (i.e. une instance d’une classe) est d’invoquer l’opérateur d’instanciation « new » suivi d’un constructeur de la classe désirée.
L’opérateur « new » forme et retourne une référence à l’objet instancié.Cette référence peut être conservée dans une variable objet compatible avec la classe de l’objet.Chaque référence est unique et constante tout au long de la vie de l’objet. Lorsque, dans le programme, il n’existe plus aucune référence à un objet, celui-ci peut être détruit.
Un constructeur est une méthode spéciale de la classe qui n’est pas une méthode d’instance.Il assure la double fonction (1) d’initialisation de l’état d’un objet nouvellement instancié, et ce, (2) d’une manière cohérente (de sorte qu’aucune méthode d’instance de l’objet ne puisse lever d’exception du fait de l’état même de l’objet).
Une classe
+ Définition des variables et méthodes d’instance
Ses constructeurs
new <constructeur> (<param>)new <constructeur> (<param>)
<un nom de variable-objet><un nom de variable-objet>
17
Cours JAVA / Y.Laborde
L’encapsulation [introduction au concept d’objet]
Comment plusieurs objets d’une même classe obtiennent-ils chacun un état qui leur est propre ? Et comment partagent-ils leur méthodes ?
La classe Domino
+ Définition des variables d’instance
Ses constructeurs
d2 = new Domino (3,4)
int : m1 = 3int : m2 = 4
_______________________________
pointeur sur MI : boolean estDouble () Domino retourné ()
d1 = new Domino (1,2)
int : m1 = 1int : m2 = 2
_______________________________
pointeur sur MI : boolean estDouble () Domino retourné ()
d2d1
Chaque objet nouvellement instancié se voit allouer un espace mémoire pour stocker :- les valeurs de ses propres variables d’instances- un pointeur sur une table commune d’accès aux méthodes d’instances (* en première approximation car d’autres informations seront accessibles,comme le nom de la classe, …)
…
…
+ Table commune d’accès aux méthodes d’instance*
18
Cours JAVA / Y.Laborde
Java : un langage Orienté Objet
LES CONCEPTS de L’ORIENTE OBJET :
L’encapsulation : introduction au concept de classe introduction au concept d’objet Le protocole de communication : L’envoi de messages (le mode inter-objets)
19
Cours JAVA / Y.Laborde
Le protocole de communication
L’envoi de message : le mode inter-objetsUne classe ayant été définie et un objet ayant été instancié,
comment invoquer une méthode de l’objet ?Dans les langages structurés et procéduraux :
Dans les langages Orientés Objets :
public static int main ( String[] args )
{ Domino d = new Domino (3,6) ;
if ( d.estDouble ( ) ) … }
public class Domino { ses constructeurs+ ses variables d’instance
+ ses méthodes d’instance }
int main (void) {Domino d = {3;6} ;if ( estDouble (&d) ) …
}
typedef struct { int m1, m2 ; } Domino ;
boolean estDouble (Domino* d) {…}
on invoquait directement une fonction en lui fournissant la structure de donnée sur laquelleelle devait agir :
Une fois instanciés, les objets renferment et leurs propres structures de données et les méthodes capables d’agir sur ces données. À partir de là, il est normal de demander à l’objet lui-même d’appliquer la méthode souhaitée.
C’est l’envoi de message !
20
Cours JAVA / Y.Laborde
Le protocole de communication
L’envoi de message : le mode inter-objets
1re forme générale de l’envoie de message :
<objet receveur> . <message> ( <paramètres> )
c’est lanotation pointée
(classique)
désigne l’objet destinataire du
message
débute la zone des paramètres
(obligatoire)
termine la zone des paramètres
(obligatoire)
c’est le nom d’une méthode de l’objet
receveur
liste conforme à la signature de la
méthode (optionnelle)
Message envoyé
depuis un objet
émetteur qui
récupèrera sa valeur de
retour
21
Cours JAVA / Y.Laborde
Le protocole de communication
L’envoi de message : le mode inter-objets
Le mode inter-objets permet d’établir une communication d’objet à objet ; les deux objets étant distincts.
Exemple 2 :Lorsqu’un joueur désire piocher un domino, il faut :
- un objet joueur ex: « j1 »- un objet pioche ex: « p »- une méthode capable d’extraire un domino de la pioche
Comment la pioche peut-elle être effectuée ?
Pour cela, un objet Joueur « j1 » devra connaître un objet Pioche « p », lequel devra disposer d’une méthode permettant de piocher « Domino piocheUnDomino ( ) {…} ».
Depuis une méthode du joueur « j1 », la demande d’un domino de la pioche pourra alors prendre la forme suivante :
Domino dominoPioché = p.piocheUnDomino ( ) ;=> ici, l’objet joueur « j1 » demande à l’objet pioche « p » de lui fournir un domino
Un joueur
j1
qui sait qu’il doitpiocher
une pioche
d
un domin
o
doitconnaître
pouvant fournir
22
Cours JAVA / Y.Laborde
Le protocole de communication
Exemple 3 :Avant de jouer, un joueur doit savoir si au moins un des dominos de sa main peut ou non être accolé a droite ou à gauche de la ligne de jeu.
1 3 3 5
55
5 2
6 2
4 3
2 2La main
du joueurLa ligne de jeu
Ce domino est-il jouable à l’une des extrémités de cette ligne de jeu ?
Ce domino est-il accolable à ce domino ?6 2
dM
1 2
dEq
Le joueur peut ainsi envoyer un message en mode inter-objet à chaque domino de sa main :
L’envoi de message : le mode inter-objetsLe mode inter-objets permet d’établir une communication
d’objet à objet ; les deux objets étant distincts.
À partir de là, il est naturel (en orienté objet) que le joueur demande à l’un des deux dominos s’il peut être accolé à l’autre.Pour cela, la classe Domino doit disposer d’une méthode d’instance prenant un autre domino en paramètre. Soit, dans la classe Domino : boolean accolableA (Domino d)
Pour cela, supposons qu’il dispose :- d’un domino de sa main ex: « dM »- du domino équivalent à la ligne de jeu ex: « dEq »
if ( dM.accolableA (dEq) ) … OU if ( dEq.accolableA (dM) ) …
23
Cours JAVA / Y.Laborde
Java : un langage Orienté Objet
LES CONCEPTS de L’ORIENTE OBJET :
L’encapsulation : introduction au concept de classe introduction au concept d’objet Le protocole de communication : L’envoi de messages (le mode inter-objets) L’envoi de messages (le mode intra-objet)
24
Cours JAVA / Y.Laborde
Le protocole de communication
L’envoi de message : le mode intra-objet
Exemple 4 : (suite de l’exemple 3 « Envoi de message en mode inter-objets »)Dans l’exemple 3, nous en étions arrivé à ce qu’un domino (6,2) de la main du joueur reçoive le message « boolean accolableA (Domino d) » avec comme paramètre le domino équivalent à la ligne de jeu (1,2).
Le mode intra-objet permet d’établir une communication d’un objet vers lui-même.
Le domino (6,2) va tester si le domino (1,2) peut être accolé à droite de lui-même et sinon à sa gauche.Pour cela supposons qu’il fasse appel à deux méthodes d’instance internes à sa classe, soit :
- dans la classe Domino : boolean accolableADroite (Domino d)- dans la classe Domino : boolean accolableAGauche (Domino d)
Ces deux méthodes d’instance de Domino sont appelées depuis un domino, elles nécessitent donc le mode d’envoi de message intra-objet (i.e. d’un objet vers lui-même).Or, la référence portée par « dM », et qui est connue au niveau du joueur, ne l’est pas par le domino (6,2) qui reçoit le message en provenance du joueur !
Comment donc un domino qui ne sait pas comment il s’appelle peut-il s’envoyer un message ?
Comment le domino (6,2) peut-t-il procéder ?
25
Cours JAVA / Y.Laborde
Le protocole de communication
Dans tous les langages objets, chaque objet, s’il veut référer à lui-même, dispose d’une auto-référence (en anglais on parle de « self » qui désigne l’objet lui-même).
2me forme générale de l’envoie de message :
<objet receveur> . <message> ( <paramètres> )
désigne l’objet destinataire du
message
Ce peut être soit :- une référence externe (portée par une variable objet)- une référence interne (portée par this)
En Java, cette auto-référence est accessible à l’aide du mot réservé « this ».
Ainsi, tout objet peut s’envoyer un message en propre en désignant l’objet receveur du message par « this ». C’est l’envoi de message intra-objet (i.e. d’un objet vers lui-même).
Techniquement, « this » est une variable :• non modifiable par le programmeur• en permanence mise à jour avec l’OID (la référence) de l’objet actif (i.e. dans lequel se trouve l’instruction en cours d’exécution)
26
Cours JAVA / Y.Laborde
Le protocole de communication
Solution de l’exemple 4 : ( « Envoi de message en mode intra-objets » )Nous en étions arrivés à ce qu’un domino utilise deux méthodes d’instance internes à sa classe :
- boolean accolableADroite (Domino d)- boolean accolableAGauche (Domino d)
Il suffit donc de munir la classe Domino de ces deux méthodes ainsi que de celle qui les utilise, soit :- boolean accolableA (Domino d)
class Domino { // La classe Dominoint m1 ; // marqueDroiteint m2 ; // marqueGauche
public Domino ( int vm1 , int vm2 ) // un CONSTRUCTEUR de domino{ m1 = vm1 ; m2 = vm2 ; }
boolean estDouble ( ) { … } // self est-il un double ?Domino retourné ( ) { … } // former le domino retourné à partir de self
boolean accolableA (Domino d) // self est-il accolable à droite ou à gauche de d ?{ return this.accolableADroite (d) || this.accolableAGauche (d) ; }
boolean accolableADroite (Domino d) // self est-il accolable à droite de d ?{ return this.m1 == d.m2 || this.m2 == d.m2 ; }
OU BIEN en utilisant une méthode de self :{ return this.m1 == d.m2 || this.retourné ( ).m1 == d.m2 ; }
boolean accolableAGauche (Domino d) // self est-il accolable à gauche de d ?{ … même principe que accolableADroite() … }
}
Attention ! 1er effet de bord :Avec cette implémentation, self a été modifié durablement !(voir le code en diapo #6)
Attention ! 2nd effet de bord :L’ordre d’exécution des termes de l’opérateur "||" peut fausser l’algorithme !
Formes d’envoi de message sans effet de bord
27
Cours JAVA / Y.Laborde
Java : un langage Orienté Objet
LES CONCEPTS de L’ORIENTE OBJET :
L’encapsulation : introduction au concept de classe introduction au concept d’objet Le protocole de communication : L’envoi de messages (le mode inter-objets) L’envoi de messages (le mode intra-objet) L’encapsulation contrôlée : la notion de « package »
28
Cours JAVA / Y.Laborde
L’encapsulation contrôlée
La notion de « package » (première approche)
Les packages Java fournissent le moyen de regrouper des classes en modules.
Toute problématique complexe peut être décomposée en sous-problématiques plus simples dont le jeu d’interactions satisfait au problème global. Une telle décomposition, menée rigoureuse-ment, permet d’isoler des sous-parties spécialisées qui ont l’avantage, par la suite, d’être utilisables au travers de comportements prédéfinis simplifiés.
En Java, chaque partie forme un système de classes qui peut être regroupé au travers d’une entité englobante appelée package.
Exemple : le package « java.net » permet de prendre en charge les aspects réseau d’adresse IP et de communication entre ordinateurs.
Exemple : le package « java.awt » permet de prendre en charge les aspects concernant les interfaces homme/machine.
Exemple : le package « dominos » permettrait de prendre en charge tout ce qui concerne les besoins d’une application destinée à jouer aux dominos.
29
Cours JAVA / Y.Laborde
L’encapsulation contrôlée
Les packages Java sont séparés entre eux par des frontières parfois franchissables, parfois non.
Un package étant défini, il regroupe un ensemble de classes dont toutes ne sont pas utiles de l’extérieur du package.
Exemple : le package « password » qui prend en charge la saisie, l’archivage et la reconnaissance de mots de passe.
Dans ce cas, l’utilisateur d’un tel package aura naturellement accès à tous les comportements du package à l’exclusion de l’algorithmique de cryptage et de décryptage qui resteront inviolables de sorte à empêcher toute fraude.
Par défaut, en Java, lorsqu’aucun spécificateur d’accès n’est précisé, l’accès est défini sur la totalité du package contenant.
30
Cours JAVA / Y.Laborde
Java : un langage Orienté Objet
LES CONCEPTS de L’ORIENTE OBJET :
L’encapsulation : introduction au concept de classe introduction au concept d’objet Le protocole de communication : L’envoi de messages (le mode inter-objets) L’envoi de messages (le mode intra-objet) L’encapsulation contrôlée : la notion de « package » les spécificateurs d’accès aux classes et à leurs instances
31
Cours JAVA / Y.Laborde
L’encapsulation contrôlée
Les spécificateurs d’accès contrôlé aux classes et à leurs instances
(première approche)
Le spécificateur PUBLIC :package dominos;
// La classe Dominopublic class Domino {
…}
La classe Domino et ses instances sont accessiblesde TOUS les packages.
Restriction d’accès : aucune
Le spécificateur PAR DÉFAUT :package dominos;
// La classe Dominoclass Domino {
…}
La classe Domino et ses instances ne sont accessiblesQUE de leur propre package
(c’est-à-dire depuis toute classe ou objet du package « dominos »)
Restriction d’accès : package
32
Cours JAVA / Y.Laborde
Java : un langage Orienté Objet
LES CONCEPTS de L’ORIENTE OBJET :
L’encapsulation : introduction au concept de classe introduction au concept d’objet Le protocole de communication : L’envoi de messages (le mode inter-objets) L’envoi de messages (le mode intra-objet) L’encapsulation contrôlée : la notion de « package » les spécificateurs d’accès aux classes et à leurs instances les spécificateurs d’accès aux champs des objets
33
Cours JAVA / Y.Laborde
L’encapsulation contrôlée
Les spécificateurs d’accès contrôlé aux champs des objets(première approche)
Le spécificateur PUBLIC :package dominos;public class Domino { … public boolean estDouble ( ) {…}}
La méthode boolean estDouble() est accessible sur TOUTES les instances de classe Domino.
Restriction d’accès : aucune mais reste subordonnée à la visibilité de la classe(qui devrait logiquement être déclarée public comme ici !)
Le spécificateur PRIVATE :package dominos;public class Domino { … private boolean estDouble ( ) {…}}
La méthode boolean estDouble() n’est accessible QUE des instances de classe Domino elles-mêmes.
Restriction d’accès : l’instance de classe elle-même
Le spécificateur PAR DÉFAUT :package dominos;public class Domino { … boolean estDouble ( ) {…}}
La méthode boolean estDouble() est accessible DE TOUT le package « dominos ».
Restriction d’accès : package
34
Cours JAVA / Y.Laborde
Java : un langage Orienté Objet
LES CONCEPTS de L’ORIENTE OBJET :
L’encapsulation : introduction au concept de classe introduction au concept d’objet Le protocole de communication : L’envoi de messages (le mode inter-objets) L’envoi de messages (le mode intra-objet) L’encapsulation contrôlée : la notion de « package » les spécificateurs d’accès aux classes et à leurs instances les spécificateurs d’accès aux champs des objets le bon usage de l’encapsulation à accès contrôlé
35
Cours JAVA / Y.Laborde
L’encapsulation contrôlée
Le bon usage de l’encapsulation à accès contrôlé (première approche)
[1] Appliquer la restriction maximale de visibilité aux classes, instances et champs d’objetsEn visant à ne pas élargir inconsidérément l’accès aux entités des programmes, cette règle très
générale prévient de mauvaises utilisations, intentionnelles ou non.De là, découlent les règles suivantes :
[2] Toujours préférer l’accès « package » (accès le plus restreint) TRÈS COURANT
Pour les CLASSES et leurs INSTANCES :
[3] Envisager ensuite l’accès « public » (accès le plus large) TRÈS COURANT
[4] Toujours préférer l’accès « private » (accès le plus restreint) TRÈS COURANT
Pour les champs « VARIABLES D’INSTANCE » des objets :
[5] Envisager ensuite l’accès « package » (accès médian) ASSEZ COURANT
[6] En dernier lieu accorder l’accès « public » (accès le plus large) TRÈS RARE !!!
[7] Envisager l’accès « private » (accès le plus restreint) RARE !
Pour les champs « MÉTHODES D’INSTANCE » des objets :
[8] Envisager ensuite l’accès « package » (accès médian) ASSEZ COURANT
[9] En dernier lieu accorder l’accès « public » (accès le plus large) TRÈS COURANT