Java : un langage Orienté Objet

Présentation au sujet: "Java : un langage Orienté Objet"— Transcription de la présentation:

1 Java : un langage Orienté Objet
Cours LOO / Y.Laborde Juin 2002 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é Cours JAVA / Y.Laborde

2 Java : un langage Orienté Objet
Cours LOO / Y.Laborde Juin 2002 Java : un langage Orienté Objet LES CONCEPTS de L’ORIENTE OBJET : L’encapsulation : introduction au concept de classe Cours JAVA / Y.Laborde

3 L’encapsulation [introduction au concept de classe]
Qu’y avait-il avant l’objet ? Principalement, les « langages structurés et procéduraux » 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) Comment, dans cette famille, exprime-t-on l’algorithmique ? Dans cette famille, l’algorithmique s’exprime par des ordres séquentiels d’exécution des instructions d’un programme. puis Fais ceci ; Fais cela ; etc. Cours JAVA / Y.Laborde

4 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 ; …} 3. Exemple de fonction spécialisée sur le type 1. Déclaration et définition d’un type 2. Nom du nouveau type Cours JAVA / Y.Laborde

5 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 D’un côté, on définit toutes les structures de données utilisées par le programme : DATA (*.h) [ Struct S1 ] [ Struct S2 ] [ Struct S3 ] … [ Struct SN ] De l’autre, on définit toutes les fonctionnalités nécessaires : CODE (*.c) [ Fun F1 ] [ Fun F2 ] [ Fun F3 ] … [ FunFM ] 1. Module regroupant ce qui se rapporte aux dominos 2. Module regroupant ce qui se rapporte aux joueurs 3. La programmation modulaire fait virtuellement apparaître des entités entre lesquelles des communications sont établies Cours JAVA / Y.Laborde

6 L’encapsulation [introduction au concept de classe]
Cours LOO / Y.Laborde Juin 2002 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 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) DATA CODE [ Struct S1 ] [ Fun F1 ] [ Fun F2 ] [ Struct S2 ] [ Fun F3 ] [ Struct S3 ] int m1 ; int m2 ; … boolean estDouble () {fais ceci ; fais cela ; …} Domino retourné ( ) Cours JAVA / Y.Laborde

7 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 traditionnellement définie encapsulant 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 ; // 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 ; // La classe Domino class { } // 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 ; } 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 ; } // 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 ; } Cours JAVA / Y.Laborde

8 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 mais cela ne va pas sans conséquences : // 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 // structure Domino typedef struct { int m1 ; // marqueDroite int m2 ; // marqueGauche } 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 ; } // Fonction retourné : Domino retourné ( ) { int m = m1 ; // échange m1 = m2 ; // des marques m2 = m ; // du domino return this ; } 1. La classe joue simultanément le rôle d’une structure de données et d’une structure fonctionnelle 2. La structure de donnée est déclarée identiquement mais à l’intérieur de la classe // 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 ; } 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 à l’objet sur lequel la fonction est en train de travailler Cours JAVA / Y.Laborde

9 Java : un langage Orienté Objet
Cours LOO / Y.Laborde Juin 2002 Java : un langage Orienté Objet LES CONCEPTS de L’ORIENTE OBJET : L’encapsulation : introduction au concept de classe introduction au concept d’objet Cours JAVA / Y.Laborde

10 L’encapsulation [introduction au concept d’objet]
Cours LOO / Y.Laborde Juin 2002 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éciale appelée « opération d’instanciation » Les variables d et i sont des « valeurs d’un type ». Elles ont été obtenues par instanciations. // 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 ; … } // depuis la fonction main par exemple int main (void) { Domino d = { m1=1; m2=2 } ; int i = 33 ; … } // depuis la fonction main par exemple int main (void) { Domino d = { m1=1; m2=2 } ; int i = 33 ; … } // depuis la fonction main par exemple int main (void) { Domino d = { m1=1; m2=2 } ; int i = 33 ; … } 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 L’allocation se traduit implicitement par la génération d’une adresse mémoire. Valeur de m1 : int = 1 Valeur de m2 : int = 2 Valeur de i : int = 33 Mémoire basse Mémoire haute | | | | | | | | | | | | | | | | | Cours JAVA / Y.Laborde instanciation du domino d instanciation de l’entier i

11 L’encapsulation [introduction au concept d’objet]
Cours LOO / Y.Laborde Juin 2002 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 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 ) ; … } 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 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 ) ; … } } class MonAppli { // depuis une classe … // … qui contient la fonction main public static int main (String[] args) { Domino d = new Domino ( 1, 2 ) ; … } } La variable d est un « 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) L’allocation se traduit implicitement par la génération d’une adresse mémoire. Cette adresse sera une référence (ou OID ) sur l’objet construit => voir plus loin Valeur de m1 : int = 1 Valeur de m2 : int = 2 Mémoire basse Mémoire haute | | | | | | | | | | | | | | | | | Cours JAVA / Y.Laborde instanciation du domino d

12 L’encapsulation [introduction au concept d’objet]
Cours LOO / Y.Laborde Juin 2002 L’encapsulation [introduction au concept d’objet] Une classe peut accepter plusieurs « constructeurs d’objets » Ils se différencient obligatoirement par leurs listes de paramètres // La classe Domino class Domino { int m1 ; // marqueDroite int m2 ; // marqueGauche // CONSTEUR de domino à 2 arguments public Domino ( int vm1 , int vm2 ) { m1 = vm1 ; m2 = vm2 ; } // CONSTEUR de domino à 1 argument public Domino ( int vm ) { m1 = vm ; m2 = vm ; } // CONSTEUR 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 ( ) ; Chaque constructeur initialise l’objet selon son rôle. Par exemple, le constructeur à un argument sert pour former un double. Les constructeurs remplacent les méthodes d’initialisation du C ! Ces dernières ne sont donc plus utilisables pour les objets ! 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 Cours JAVA / Y.Laborde

13 L’encapsulation [introduction au concept d’objet]
Cours LOO / Y.Laborde Juin 2002 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 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 En Java, comme dans beaucoup de langages, les références sont en réalité des pointeurs. Mais puisque Java ne permet pas de manipuler les pointeurs, les références n’apparaissent pas comme des indirections et sont utilisables comme des données à accès immédiat. Par ailleurs, une référence spéciale « null » est automatiquement associée à une variable objet qui n’a jamais été instanciée ou qui est directement affectée à la valeur « null ». La valeur null indique que la variable d1 ne référencera plus un objet Cours JAVA / Y.Laborde

14 L’encapsulation [introduction au concept d’objet]
Cours LOO / Y.Laborde Juin 2002 L’encapsulation [introduction au concept d’objet] Les références ou OID : construction, duplication ou extinction CONSTRUCTION : Une nouvelle référence est créée à chaque instanciation par l’opérateur new suivi d’un constructeur 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 donc pas détruit ! } DUPLICATION : Une référence peut être dupliquée par simple affectation 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. La classe Domino int m1, m2 ; null Lorsque la dernière référence à l’objet est perdue, ce dernier n’est plus accessible et il peut être détruit. => Voir plus loin Garbage Collector d1 m1= 1 m2= 2 d2 d3 d3 m1= 1 m2= 2 d4 m1= 4 m2= 5 m1= 3 m2= 3 Cours JAVA / Y.Laborde

15 Terminologie de l’Orienté Objet (1)
Cours LOO / Y.Laborde Juin 2002 Terminologie de l’Orienté Objet (1) CLASSE : OBJET ou INSTANCE : MTHODE D’INSTANCE : VARIABLE D’INSTANCE : en NOM : en VALEUR : TAT : 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. ex: la classe Domino 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. ex: d1 = new Domino ( 3,6 ) 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 » ex: boolean estDouble ( ) {…} Les objets d’une même classe partagent les caractéristiques structurelles (appelées variables d’état ou variables d’instances) et fonctionnelles (appelées méthodes d’instance) décrites dans leur classe d’appartenance. Mais chacun possède ses propres valeurs de champs associée à la structure. - partagent les noms des caractéristiques structurelles de leur classe, appelées « variables d’état » ou « variables d’instances » ex:  un domino : int m1 ; - possèdent chacun leurs propres valeurs liées aux variables d’état ex: pour le domino d1, m1 = 3 L’ensemble des valeurs des variables d’état est appelé l’« état » de l’objet. ex: état du domino d1 : (3,6) Cours JAVA / Y.Laborde

16 Terminologie de l’Orienté Objet (2)
OPRATEUR D’INSTANCIATION : RFRENCE ou OID : 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. new <constructeur> (<param>) 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 nom de variable-objet> 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 Cours JAVA / Y.Laborde

17 L’encapsulation [introduction au concept d’objet]
Cours LOO / Y.Laborde Juin 2002 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 ? d1 = new Domino (1,2) d2 = new Domino (3,4) … La classe Domino + Définition des variables d’instance Ses constructeurs int : m1 = 1 int : m2 = 2 _______________________________  pointeur sur MI : boolean estDouble () Domino retourné () int : m1 = 3 int : m2 = 4 _______________________________  pointeur sur MI : boolean estDouble () Domino retourné () + Table commune d’accès aux méthodes d’instance* d1 d2 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, …) Cela complète la diapo 10 : allocation mémoire des seules variables d’instance Cours JAVA / Y.Laborde

18 Java : un langage Orienté Objet
Cours LOO / Y.Laborde Juin 2002 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) Cours JAVA / Y.Laborde

19 Le protocole de communication
Cours LOO / Y.Laborde Juin 2002 Le protocole de communication L’envoi de message : le mode inter-objets Une 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 : on invoquait directement une fonction en lui fournissant la structure de donnée sur laquelle elle devait agir : int main (void) { Domino d = {3;6} ; if ( estDouble (&d) ) … } typedef struct { int m1, m2 ; } Domino ; boolean estDouble (Domino* d) {…} Dans les langages Orientés Objets : 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 ! L’envoi de messages : Traiter les messages depuis l’extérieur d1.estDouble() => la méthode n’a pas besoin de paramètre comme en C car l’objet receveur est fourni par le protocole d’envoi de message. 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 } Cours JAVA / Y.Laborde

20 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> ) Message envoyé depuis un objet émetteur qui récupèrera sa valeur de retour désigne l’objet destinataire du message c’est le nom d’une méthode de l’objet receveur liste conforme à la signature de la méthode (optionnelle) c’est la notation pointée (classique) débute la zone des paramètres (obligatoire) termine la zone des paramètres (obligatoire) Cours JAVA / Y.Laborde

21 Le protocole de communication
Cours LOO / Y.Laborde Juin 2002 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. Un joueur j1 qui sait qu’il doit piocher 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 ? une pioche d doit connaître pouvant fournir un domino 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 => ici, depuis l’objet joueur « j1 », un message « piocheUnDomino() » a été envoyé à un objet pioche « p » pour lui demander de retourner un domino. => ici, l’objet joueur « j1 » demande à l’objet pioche « p » de lui fournir un domino. Cours JAVA / Y.Laborde

22 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 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 6 2 4 3 1 3 5 2 Ce domino est-il jouable à l’une des extrémités de cette ligne de jeu ? Pour cela, supposons qu’il dispose : d’un domino de sa main ex: « dM » du domino équivalent à la ligne de jeu ex: « dEq » 6 2 dM 1 2 dEq Ce domino est-il accolable à ce domino ? À 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) Le joueur peut ainsi envoyer un message en mode inter-objet à chaque domino de sa main : if ( dM.accolableA (dEq) ) … OU if ( dEq.accolableA (dM) ) … Cours JAVA / Y.Laborde

23 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) Cours JAVA / Y.Laborde

24 Le protocole de communication
Cours LOO / Y.Laborde Juin 2002 Le protocole de communication L’envoi de message : le mode intra-objet Le mode intra-objet permet d’établir une communication d’un objet vers lui-même. 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). Comment le domino (6,2) peut-t-il procéder ? 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) Texte de l’exemple 3 : Avant de jouer, un joueur doit savoir si son domino peut ou non être accoler a droite ou à gauche d’une ligne de jeu. Pour cela, supposons qu’il dispose : du domino équivalent à la ligne de jeu ex: « dEq » d’un domino de sa main ex: « dM » À 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 ; et ce grâce à une méthode d’instance de la classe Domino, soit : dans la classe Domino : Boolean accolableA (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 ? Cours JAVA / Y.Laborde

25 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). En Java, cette auto-référence est accessible à l’aide du mot réservé « this ». 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) 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). 2me forme générale de l’envoie de message : <objet receveur> . <message> ( <paramètres> ) Ce peut être soit : - une référence externe (portée par une variable objet) - une référence interne (portée par this) désigne l’objet destinataire du message Cours JAVA / Y.Laborde

26 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 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() … } } Formes d’envoi de message sans effet de bord 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 ! Cours JAVA / Y.Laborde

27 Java : un langage Orienté Objet
Cours LOO / Y.Laborde Juin 2002 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 » Cours JAVA / Y.Laborde

28 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. Cours JAVA / Y.Laborde

29 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. Cours JAVA / Y.Laborde

30 Java : un langage Orienté Objet
Cours LOO / Y.Laborde Juin 2002 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 Cours JAVA / Y.Laborde

31 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 Domino public class Domino { … } La classe Domino et ses instances sont accessibles de TOUS les packages. Restriction d’accès : aucune Le spécificateur PAR DÉFAUT : La classe Domino et ses instances ne sont accessibles QUE de leur propre package (c’est-à-dire depuis toute classe ou objet du package « dominos ») Restriction d’accès : package package dominos; // La classe Domino class Domino { … } Cours JAVA / Y.Laborde

32 Java : un langage Orienté Objet
Cours LOO / Y.Laborde Juin 2002 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 Cours JAVA / Y.Laborde

33 L’encapsulation contrôlée
Les spécificateurs d’accès contrôlé aux champs des objets (première approche) Le spécificateur PUBLIC : 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 !) package dominos; public class Domino { … public boolean estDouble ( ) {…} } 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 Cours JAVA / Y.Laborde

34 Java : un langage Orienté Objet
Cours LOO / Y.Laborde Juin 2002 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é Cours JAVA / Y.Laborde

35 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’objets En 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 : Pour les CLASSES et leurs INSTANCES : [2] Toujours préférer l’accès « package » (accès le plus restreint) TRÈS COURANT [3] Envisager ensuite l’accès « public » (accès le plus large) TRÈS COURANT Pour les champs « VARIABLES D’INSTANCE » des objets : [4] Toujours préférer l’accès « private » (accès le plus restreint) TRÈS COURANT [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 !!! Pour les champs « MÉTHODES D’INSTANCE  » des objets : [7] Envisager l’accès « private » (accès le plus restreint) RARE ! [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 Cours JAVA / Y.Laborde