1 cours java / y.laborde java : un langage orienté objet les concepts de loriente objet :...

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




L’encapsulation : introduction au concept de classe

3


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.


4





// 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





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



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


// 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’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



} Domino ;




} Domino ;



} Domino ;



} Domino ;




} Domino ;



// La classe Dominoclass {

}

Domino

// La classe Dominoclass Domino {

int m1 ; // marque Droite du dominoint m2 ; // marque Gauche du domino

}



// Fonction estDouble :boolean estDouble ( )

{ return m1 == m2 ; }

}




{ return m1 == m2 ; }

// Fonction retourné :Domino retourné ( )

{ int m = m1 ; // échangem1 = m2 ; // des marquesm2 = m ; // du dominoreturn this ;

} }

8


mais cela ne va pas sans conséquences :



L’Orienté Objet transforme :

la notion de type => en une notion de classe



} Domino ;





{ return m1 == m2 ; }



} }




{ return m1 == m2 ; }



} }

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




introduction au concept d’objet

L’encapsulation : introduction au concept de classe

10


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 »



} 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| | | | | | | | | | | | | | | | |


Domino d = { m1=1; m2=2 } ;int i = 33 ;

… }

instanciation du domino d

Valeur de m1 :

int = 1

Valeur de m2 :

int = 2


Domino d = { m1=1; m2=2 } ;int i = 33 ;

… }

Valeur de i :int = 33

instanciation de l’entier i


Domino d = { m1=1; m2=2 } ;int i = 33 ;

… }

11



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 ) ;

… }}




… }}

instanciation du domino d



{ m1 = vm1 ; m2 = vm2 ; }}

Valeur de m1 :

int = 1

Valeur de m2 :

int = 2



{ m1 = vm1 ; m2 = vm2 ; }}




… }}

12





// 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 ; }}



// 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



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




{ 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


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


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



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




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


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 :


{ 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



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



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



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




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



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



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



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)


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




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


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



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




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



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 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




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



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




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



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

1 cours java / y.laborde java : un langage orienté objet les concepts de loriente objet :...

Documents