La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

1 Cours JAVA / Y.Laborde Java : un langage Orienté Objet LES CONCEPTS de LORIENTE OBJET : Lencapsulation : introduction au concept de classe introduction.

Présentations similaires


Présentation au sujet: "1 Cours JAVA / Y.Laborde Java : un langage Orienté Objet LES CONCEPTS de LORIENTE OBJET : Lencapsulation : introduction au concept de classe introduction."— Transcription de la présentation:

1

2 1 Cours JAVA / Y.Laborde Java : un langage Orienté Objet LES CONCEPTS de LORIENTE OBJET : Lencapsulation : introduction au concept de classe introduction au concept dobjet Le protocole de communication : Lenvoi de messages (le mode inter-objets) Lenvoi de messages (le mode intra-objet) Lencapsulation contrôlée : la notion de « package » les spécificateurs daccès aux classes et à leurs instances les spécificateurs daccès aux champs des objets le bon usage de lencapsulation à accès contrôlé

3 2 Cours JAVA / Y.Laborde Java : un langage Orienté Objet LES CONCEPTS de LORIENTE OBJET : Lencapsulation : introduction au concept de classe

4 3 Cours JAVA / Y.Laborde Comment, dans cette famille, exprime-t-on lalgorithmique ? Lencapsulation [introduction au concept de classe] Quy avait-il avant lobjet ? Principalement, les « langages structurés et procéduraux » Nous resterons dans la famille des « langages impératifs » (soit celle qui simpose majoritairement en développement) Dans cette famille, lalgorithmique sexprime par des ordres séquentiels dexécution des instructions dun programme. Fais ceci ;Fais cela ; puis etc. Principalement, les « langages structurés et procéduraux »

5 4 Cours JAVA / Y.Laborde Lencapsulation [introduction au concept de classe] Quy avait-il avant lobjet ? Principalement, les « langages structurés et procéduraux » // fichier dentê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 dun type 3. Exemple de fonction spécialisée sur le type

6 5 Cours JAVA / Y.Laborde Lencapsulation [introduction au concept de classe] Quy avait-il avant lobjet ? Principalement, les « langages structurés et procéduraux » Examinons une version plus réaliste dun programme écrit dans un tel langage [ Struct S1 ]… Dun côté, on définit toutes les structures de données utilisées par le programme : DATA (*.h) [ Fun F1 ][ Fun F2 ]… De lautre, 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

7 6 Cours JAVA / Y.Laborde Lencapsulation [introduction au concept de classe] Quel principal changement lOrienté Objet apporte-t-il ? Il opère dune manière effective ce que les techniques de programmation modulaire neffectuent que virtuellement en procédant à lencapsulation 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 DominoLa classe Joueur Chaque classe répond aux 3 caractéristiques dun type : 1. Le nom du type (la classe) 2. Les données du type (les data) 3. Les fonctionnalités capables dopé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 ; …}

8 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 Domino typedef struct { int m1 ; // marqueDroite int m2 ; // marqueGauche } Domino ; Lencapsulation [introduction au concept de classe] Quel principal changement lOrienté Objet apporte-t-il ? LOrienté Objet transforme : la notion de type=>en une notion de classe traditionnellement définieencapsulant tout ce qui a trait de façon éparse au type correspondant // structure Domino typedef struct { int m1 ; // marqueDroite int 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 Domino typedef struct { int m1 ; // marqueDroite int m2 ; // marqueGauche } Domino ; // structure Domino typedef struct { int m1 ; // marqueDroite int m2 ; // marqueGauche } Domino ; // structure Domino typedef struct { int m1 ; // marqueDroite int 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 Domino typedef struct { int m1 ; // marqueDroite int 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 Domino class{ } Domino // La classe Domino class Domino { int m1 ;// marque Droite du domino int m2 ;// marque Gauche du domino } // La classe Domino class Domino { int m1 ;// marque Droite du domino int m2 ;// marque Gauche du domino // Fonction estDouble : boolean estDouble ( ) { return m1 == m2 ; } } // La classe Domino class Domino { int m1 ;// marque Droite du domino int m2 ;// marque Gauche du domino // Fonction estDouble : boolean estDouble ( ) { return m1 == m2 ; } // Fonction retourné : Domino retourné ( ) {int m = m1 ;// échange m1 = m2 ;// des marques m2 = m ;// du domino return this ; }

9 8 Cours JAVA / Y.Laborde mais cela ne va pas sans conséquences : Lencapsulation [introduction au concept de classe] Quel principal changement lOrienté Objet apporte-t-il ? LOrienté Objet transforme : la notion de type=>en une notion de classe // structure Domino typedef struct { int m1 ; // marqueDroite int 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 Domino class Domino { int m1 ;// marque Droite du domino int m2 ;// marque Gauche du domino // Fonction estDouble : boolean estDouble ( ) { return m1 == m2 ; } // Fonction retourné : Domino retourné ( ) {int m = m1 ;// échange m1 = m2 ;// des marques m2 = m ;// du domino return this ; } // La classe Domino class Domino { int m1 ;// marque Droite du domino int m2 ;// marque Gauche du domino // Fonction estDouble : boolean estDouble ( ) { return m1 == m2 ; } // Fonction retourné : Domino retourné ( ) {int m = m1 ;// échange m1 = m2 ;// des marques m2 = m ;// du domino return this ; } 2. La structure de donnée est déclarée identiquement mais à linté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 champs de la structure de données (en lecture ou écriture) 5. Une référence spéciale « this » équivaut à lobjet sur lequel la fonction est en train de travailler 1. La classe joue simultanément le rôle dune structure de données et dune structure fonctionnelle

10 9 Cours JAVA / Y.Laborde Java : un langage Orienté Objet LES CONCEPTS de LORIENTE OBJET : introduction au concept dobjet Lencapsulation : introduction au concept de classe

11 10 Cours JAVA / Y.Laborde Lencapsulation [introduction au concept dobjet] Comment, partant dun type, générer des « valeurs du type » ? Cela nécessite lemploi dune opération spéciale appelée « opération dinstanciation » // structure Domino typedef struct { int m1 ; // marqueDroite int 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 dun type ». Elles ont été obtenues par instanciations. L « opération dinstanciation » réalise 2 tâches : 1. lallocation (en terme despace) dune partie de mémoire 2. linitiation (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 lentier i // depuis la fonction main par exemple int main (void) { Domino d = { m1=1; m2=2 } ; int i = 33 ; … }

12 11 Cours JAVA / Y.Laborde Lencapsulation [introduction au concept dobjet] Comment, partant dune classe, générer des « objets » ? De la même manière, on réalisera une « instanciation » class Domino { // La classe Domino int m1 ; // marqueDroite int m2 ; // marqueGauche // un CONSTRUCTEUR de domino public Domino ( int vm1, int vm2 ) { m1 = vm1 ; m2 = vm2 ; } } La variable d est un « objet » de classe Domino. Il a été obtenu par instanciation. L « opération dinstanciation » réalise 2 tâches : (en première approximation) 1. lallocation de lespace mémoire (invoquée par lopérateur « new ») 2. linitialisation de lespace 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 Domino int m1 ; // marqueDroite int m2 ; // marqueGauche // un CONSTRUCTEUR de domino public Domino ( int vm1, int vm2 ) { m1 = vm1 ; m2 = vm2 ; } } Valeur de m1 : int = 1 Valeur de m2 : int = 2 class Domino { // La classe Domino int m1 ; // marqueDroite int m2 ; // marqueGauche // un CONSTRUCTEUR de domino public 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 ) ; … } }

13 12 Cours JAVA / Y.Laborde Lencapsulation [introduction au concept dobjet] // La classe Domino class Domino { int m1 ; // marqueDroite int m2 ; // marqueGauche // CONST EUR de domino à 2 arguments public Domino ( int vm1, int vm2 ) { m1 = vm1 ; m2 = vm2 ; } // CONST EUR de domino à 1 argument public Domino ( int vm ) { m1 = vm ; m2 = vm ; } // CONST EUR de domino PAR DEFAUT public 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 dobjets » Ils se différencient obligatoirement par leurs listes de paramètres Chaque constructeur initialise lobjet 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 dinitialiser toutes les données de lobjet 2. faire en sorte dassurer la cohérence interne de lobjet

14 13 Cours JAVA / Y.Laborde Lencapsulation [introduction au concept dobjet] 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 lopérateur new =>Elle est unique et constante tout au long de la vie de lobjet ; la vie de lobjet 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 lobjet est alors déterminée par celle de la dernière référence conservée par le programme Par 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 le domino construit La valeur null indique que la variable d1 ne référencera plus un objet

15 14 Cours JAVA / Y.Laborde Lencapsulation [introduction au concept dobjet] 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) nest 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 donc pas 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 d2d3 d4 d3 nu ll Les références ou OID : construction, duplication ou extinction DUPLICATION : Une référence peut être dupliquée par simple affectation EXTINCTION : Lorsque la dernière référence dun objet est perdue, ce dernier nest plus accessible ; lobjet peut être détruit. CONSTRUCTION : Une nouvelle référence est créée à chaque instanciation par lopérateur new suivi dun constructeur

16 15 Cours JAVA / Y.Laborde Terminologie de lOrienté Objet (1) Une classe est un modèle contenant une description structurelle et fonctionnelle telle que les fonctions sont capables dagir sur les structures tout en assurant leur cohérence. Un objet (ou instance) est une entité construite (instanciée) sur la base dune classe. Il possède des caractéristiques structurelle et fonctionnelles calquées sur sa classe dappartenance. CLASSE : OBJET ou INSTANCE : M THODE DINSTANCE : VARIABLE DINSTANCE : en NOM : en VALEUR : TAT : TAT : Les objets dune même classe : - partagent les caractéristiques fonctionnelles décrites dans leur classe dappartenance. On les nomme « méthodes dinstance » - partagent les noms des caractéristiques structurelles de leur classe, appelées « variables détat » ou « variables dinstances » - possèdent chacun leurs propres valeurs liées aux variables détat Lensemble des valeurs des variables détat est appelé l« état » de lobjet. ex: la classe Domino ex: d1 = new Domino ( 3,6 ) ex: boolean estDouble ( ) {…} ex: un domino : int m1 ; ex: pour le domino d1, m1 = 3 ex: état du domino d1 : (3,6)

17 16 Cours JAVA / Y.Laborde Terminologie de lOrienté Objet (2) OP RATEUR DINSTANCIATION : DINSTANCIATION : R F RENCE ou OID : CONSTRUCTEUR : La seule méthode pour créer un objet (i.e. une instance dune classe) est dinvoquer lopérateur dinstanciation « new » suivi dun constructeur de la classe désirée. Lopérateur « new » forme et retourne une référence à lobjet instancié. Cette référence peut être conservée dans une variable objet compatible avec la classe de lobjet. Chaque référence est unique et constante tout au long de la vie de lobjet. Lorsque, dans le programme, il nexiste 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 nest pas une méthode dinstance. Il assure la double fonction (1) dinitialisation de létat dun objet nouvellement instancié, et ce, (2) dune manière cohérente (de sorte quaucune méthode dinstance de lobjet ne puisse lever dexception du fait de létat même de lobjet). Une classe + Définition des variables et méthodes dinstance Ses constructeurs new ( )

18 17 Cours JAVA / Y.Laborde Lencapsulation [introduction au concept dobjet] Comment plusieurs objets dune 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 dinstance Ses constructeurs d2 = new Domino (3,4) int : m1 = 3 int : m2 = 4 _______________________________ pointeur sur MI : boolean estDouble () Domino retourné () d1 = new Domino (1,2) int : m1 = 1 int : 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 dinstances - un pointeur sur une table commune daccès aux méthodes dinstances (* en première approximation car dautres informations seront accessibles,comme le nom de la classe, …) … … + Table commune daccès aux méthodes dinstance*

19 18 Cours JAVA / Y.Laborde Java : un langage Orienté Objet LES CONCEPTS de LORIENTE OBJET : Lencapsulation : introduction au concept de classe introduction au concept dobjet Le protocole de communication : Lenvoi de messages (le mode inter-objets)

20 19 Cours JAVA / Y.Laborde Le protocole de communication Lenvoi de message : le mode inter-objets Une classe ayant été définie et un objet ayant été instancié, comment invoquer une méthode de lobjet ? 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 dinstance + ses méthodes dinstance } 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 laquelle elle devait agir : Une fois instanciés, les objets renferment et leurs propres structures de données et les méthodes capables dagir sur ces données. À partir de là, il est normal de demander à lobjet lui-même dappliquer la méthode souhaitée. Cest lenvoi de message !

21 20 Cours JAVA / Y.Laborde Le protocole de communication Lenvoi de message : le mode inter-objets 1 re forme générale de lenvoie de message :. ( ) cest la notation pointée (classique) désigne lobjet destinataire du message débute la zone des paramètres (obligatoire) termine la zone des paramètres (obligatoire) cest le nom dune méthode de lobjet receveur liste conforme à la signature de la méthode (optionnelle) Message envoyé depuis un objet émetteur qui récupèrera sa valeur de retour

22 21 Cours JAVA / Y.Laborde Le protocole de communication Lenvoi de message : le mode inter-objets Le mode inter-objets permet détablir une communication dobjet à objet ; les deux objets étant distincts. Exemple 2 : Lorsquun joueur désire piocher un domino, il faut : - un objet joueurex: « j1 » - un objet piocheex: « p » - une méthode capable dextraire 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 dune méthode permettant de piocher « Domino piocheUnDomino ( ) {…} ». Depuis une méthode du joueur « j1 », la demande dun domino de la pioche pourra alors prendre la forme suivante : Domino dominoPioché = p.piocheUnDomino ( ) ; => ici, lobjet joueur « j1 » demande à lobjet pioche « p » de lui fournir un domino Un joueur j1 qui sait quil doit piocher une pioche d un domino doit connaître pouvant fournir

23 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 La main du joueur La ligne de jeu Ce domino est-il jouable à lune des extrémités de cette ligne de jeu ? Ce domino est-il accolable à ce domino ? 62 dM 12 dEq Le joueur peut ainsi envoyer un message en mode inter-objet à chaque domino de sa main : Lenvoi de message : le mode inter-objets Le mode inter-objets permet détablir une communication dobjet à objet ; les deux objets étant distincts. À partir de là, il est naturel (en orienté objet) que le joueur demande à lun des deux dominos sil peut être accolé à lautre. Pour cela, la classe Domino doit disposer dune méthode dinstance prenant un autre domino en paramètre. Soit, dans la classe Domino : boolean accolableA (Domino d) Pour cela, supposons quil dispose : - dun domino de sa mainex: « dM » - du domino équivalent à la ligne de jeuex: « dEq » if ( dM.accolableA (dEq) ) … OU if ( dEq.accolableA (dM) ) …

24 23 Cours JAVA / Y.Laborde Java : un langage Orienté Objet LES CONCEPTS de LORIENTE OBJET : Lencapsulation : introduction au concept de classe introduction au concept dobjet Le protocole de communication : Lenvoi de messages (le mode inter-objets) Lenvoi de messages (le mode intra-objet)

25 24 Cours JAVA / Y.Laborde Le protocole de communication Lenvoi de message : le mode intra-objet Exemple 4 : (suite de lexemple 3 « Envoi de message en mode inter-objets ») Dans lexemple 3, nous en étions arrivé à ce quun 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 dun 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 quil fasse appel à deux méthodes dinstance internes à sa classe, soit : - dans la classe Domino : boolean accolableADroite (Domino d) - dans la classe Domino : boolean accolableAGauche (Domino d) Ces deux méthodes dinstance de Domino sont appelées depuis un domino, elles nécessitent donc le mode denvoi de message intra-objet (i.e. dun objet vers lui-même). Or, la référence portée par « dM », et qui est connue au niveau du joueur, ne lest 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 sappelle peut-il senvoyer un message ? Comment le domino (6,2) peut-t-il procéder ?

26 25 Cours JAVA / Y.Laborde Le protocole de communication Dans tous les langages objets, chaque objet, sil veut référer à lui-même, dispose dune auto-référence (en anglais on parle de « self » qui désigne lobjet lui-même). 2 me forme générale de lenvoie de message :. ( ) désigne lobjet 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 à laide du mot réservé « this ». Ainsi, tout objet peut senvoyer un message en propre en désignant lobjet receveur du message par « this ». Cest lenvoi de message intra-objet (i.e. dun objet vers lui-même). Techniquement, « this » est une variable : non modifiable par le programmeur en permanence mise à jour avec lOID (la référence) de lobjet actif (i.e. dans lequel se trouve linstruction en cours dexécution)

27 26 Cours JAVA / Y.Laborde Le protocole de communication Solution de lexemple 4 : ( « Envoi de message en mode intra-objets » ) Nous en étions arrivés à ce quun domino utilise deux méthodes dinstance 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 Domino int m1 ; // marqueDroite int 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 ! 1 er effet de bord : Avec cette implémentation, self a été modifié durablement ! (voir le code en diapo #6) Attention ! 2 nd effet de bord : Lordre dexécution des termes de lopérateur "||" peut fausser lalgorithme ! Formes denvoi de message sans effet de bord

28 27 Cours JAVA / Y.Laborde Java : un langage Orienté Objet LES CONCEPTS de LORIENTE OBJET : Lencapsulation : introduction au concept de classe introduction au concept dobjet Le protocole de communication : Lenvoi de messages (le mode inter-objets) Lenvoi de messages (le mode intra-objet) Lencapsulation contrôlée : la notion de « package »

29 28 Cours JAVA / Y.Laborde Lencapsulation 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 dinteractions satisfait au problème global. Une telle décomposition, menée rigoureuse- ment, permet disoler des sous-parties spécialisées qui ont lavantage, 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 dune entité englobante appelée package. Exemple : le package « java.net » permet de prendre en charge les aspects réseau dadresse 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 dune application destinée à jouer aux dominos.

30 29 Cours JAVA / Y.Laborde Lencapsulation 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 lextérieur du package. Exemple : le package « password » qui prend en charge la saisie, larchivage et la reconnaissance de mots de passe. Dans ce cas, lutilisateur dun tel package aura naturellement accès à tous les comportements du package à lexclusion de lalgorithmique de cryptage et de décryptage qui resteront inviolables de sorte à empêcher toute fraude. Par défaut, en Java, lorsquaucun spécificateur daccès nest précisé, laccès est défini sur la totalité du package contenant.

31 30 Cours JAVA / Y.Laborde Java : un langage Orienté Objet LES CONCEPTS de LORIENTE OBJET : Lencapsulation : introduction au concept de classe introduction au concept dobjet Le protocole de communication : Lenvoi de messages (le mode inter-objets) Lenvoi de messages (le mode intra-objet) Lencapsulation contrôlée : la notion de « package » les spécificateurs daccès aux classes et à leurs instances

32 31 Cours JAVA / Y.Laborde Lencapsulation contrôlée Les spécificateurs daccès contrôlé aux classes et à leurs instances (première approche) Le spécificateur PUBLIC : package dominos; // La classe Domino public class Domino { … } La classe Domino et ses instances sont accessibles de TOUS les packages. Restriction daccès : aucune Le spécificateur PAR DÉFAUT : package dominos; // La classe Domino class Domino { … } La classe Domino et ses instances ne sont accessibles QUE de leur propre package (cest-à-dire depuis toute classe ou objet du package « dominos ») Restriction daccès : package

33 32 Cours JAVA / Y.Laborde Java : un langage Orienté Objet LES CONCEPTS de LORIENTE OBJET : Lencapsulation : introduction au concept de classe introduction au concept dobjet Le protocole de communication : Lenvoi de messages (le mode inter-objets) Lenvoi de messages (le mode intra-objet) Lencapsulation contrôlée : la notion de « package » les spécificateurs daccès aux classes et à leurs instances les spécificateurs daccès aux champs des objets

34 33 Cours JAVA / Y.Laborde Lencapsulation contrôlée Les spécificateurs daccè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 daccè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() nest accessible QUE des instances de classe Domino elles-mêmes. Restriction daccès : linstance 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 daccès : package

35 34 Cours JAVA / Y.Laborde Java : un langage Orienté Objet LES CONCEPTS de LORIENTE OBJET : Lencapsulation : introduction au concept de classe introduction au concept dobjet Le protocole de communication : Lenvoi de messages (le mode inter-objets) Lenvoi de messages (le mode intra-objet) Lencapsulation contrôlée : la notion de « package » les spécificateurs daccès aux classes et à leurs instances les spécificateurs daccès aux champs des objets le bon usage de lencapsulation à accès contrôlé

36 35 Cours JAVA / Y.Laborde Lencapsulation contrôlée Le bon usage de lencapsulation à accès contrôlé (première approche) [1] Appliquer la restriction maximale de visibilité aux classes, instances et champs dobjets En visant à ne pas élargir inconsidérément laccè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 laccès « package »(accès le plus restreint) TRÈS COURANT Pour les CLASSES et leurs INSTANCES : [3] Envisager ensuite laccès « public » (accès le plus large) TRÈS COURANT [4] Toujours préférer laccès « private »(accès le plus restreint) TRÈS COURANT Pour les champs « VARIABLES DINSTANCE » des objets : [5] Envisager ensuite laccès « package » (accès médian) ASSEZ COURANT [6] En dernier lieu accorder laccès « public » (accès le plus large) TRÈS RARE !!! [7] Envisager laccès « private »(accès le plus restreint) RARE ! Pour les champs « MÉTHODES DINSTANCE » des objets : [8] Envisager ensuite laccès « package » (accès médian) ASSEZ COURANT [9] En dernier lieu accorder laccès « public » (accès le plus large) TRÈS COURANT


Télécharger ppt "1 Cours JAVA / Y.Laborde Java : un langage Orienté Objet LES CONCEPTS de LORIENTE OBJET : Lencapsulation : introduction au concept de classe introduction."

Présentations similaires


Annonces Google