Chapitre 16

Heritage
Ce chapitre du cours traite de concepts relatifs a` la programmation objet (hierarchie de classe,
heritage, extension, masquage) et sera illustre par un exemple de representation de comptes bancaires
et doperations liees a` la manipulation de ceux-ci (retrait, depot, consultation).

16.1 Une classe simple pour representer des comptes bancaires

Decrivons maintenant la classe permettant de representer un compte bancaire. Il faut, au minimum,
connatre le proprietaire (que lon representera simplement par son nom), le numero du compte (que
lon representera par tableau de caract`eres) et la somme disponible sur le compte (representee par
un double). Pour les operations sur un compte, on se limite aux operation de retrait (on decremente si
possible le compte dune somme donnee), le depot (on augmente le compte dune somme donnee) et la
consultation (on retourne la somme disponible sur un compte). Dans le cas o`u un retrait est impossible
on l`evera une exception de type provisionInsuffisanteErreur definie separement. En plus
du constructeur par defaut, nous fournirons e galement un constructeur plus complet permettant de
construire un compte en fixant le numero, le proprietaire et le solde initial. Enfin nous proposons
e galement une methode permettant deffectuer un virement dun compte vers un autre.
Ceci conduit a` la construction de la classe suivante :
public c l a s s CompteBancaire {
String nomProprietaire ;
char [ ] numero ;
double s o l d e ;
public CompteBancaire ( ) {
}
p u b l i c C o m p t e B a n c a i r e ( S t r i n g p r o p r i o , char [ ] num , double m o n t a n t ) {
this . nomProprietaire = proprio ;
t h i s . numero = num ;
t h i s . solde = montant ;
}
p u b l i c double s o l d e C o u r a n t ( ) {
return t h i s . solde ;
}


CHAPITRE 16. HERITAGE

p u b l i c v o i d d e p o t ( double m o n t a n t ) {
t h i s . solde + = montant ;
}
p u b l i c v o i d r e t r a i t ( double m o n t a n t )
throws p r o v i s i o n I n s u f f i s a n t e E r r e u r {
System . o u t . p r i n t l n ( Appel de r e t r a i t s u r compte s i m p l e ) ;
i f ( t h i s . solde < montant ){
throw new p r o v i s i o n I n s u f f i s a n t e E r r e u r ( ) ;
}else{
s o l d e = m o n t a n t ;
}
}
p u b l i c v o i d v i r e m e n t ( C o m p t e B a n c a i r e c , double m o n t a n t )
throws p r o v i s i o n I n s u f f i s a n t e E r r e u r {
c . r e t r a i t ( montant ) ;
t h i s . depot ( montant ) ;
}
}
c l a s s p r o v i s i o n I n s u f f i s a n t e E r r e u r extends Exception {
}

On peut alors utiliser cette classe dans le programme suivant :

class Test1ComptesBancaires {
p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s )
throws p r o v i s i o n I n s u f f i s a n t e E r r e u r {
C o m p t e B a n c a i r e c1 ;
C o m p t e B a n c a i r e c2 ;
C o m p t e B a n c a i r e c3 ;
S t r i n g num1 = 123456789 ;
S t r i n g num2 = 145775544 ;
S t r i n g num3 = A4545AA54 ;
c1 = new C o m p t e B a n c a i r e ( P a u l , num1 . t o C h a r A r r a y ( ) , 1 0 0 0 . 0 0 ) ;
c2 = new C o m p t e B a n c a i r e ( P a u l , num2 . t o C h a r A r r a y ( ) , 2 3 0 0 . 0 0 ) ;
c3 = new C o m p t e B a n c a i r e ( H e n r i , num3 . t o C h a r A r r a y ( ) , 5 0 0 0 . 0 0 ) ;
c1 . d e p o t ( 1 0 0 . 0 0 ) ;
c2 . v i r e m e n t ( c1 , 1 0 0 0 . 0 0 ) ;
T e r m i n a l . e c r i r e D o u b l e ( c2 . s o l d e C o u r a n t ( ) ) ;
}
}

16.2 Extension des donnees, notion dheritage et syntaxe

Supposons maintenant que lon souhaite prendre en consideration la possibilite davoir un decouvert
sur un compte (un retrait conduit a` un solde negatif) ou la possibilite dassocier une remuneration des
depots sur un compte (compte remunere) ; ces cas ne sont pas prevus dans la classe que nous avons
definie. Une premi`ere possibilite est de modifier le code source de la classe precedente. Ceci peut im-

 NOTION DHERITAGE

16.2. EXTENSION DES DONNEES,

ET SYNTAXE

pacter tout programme (ou toute classe) qui utilise cette classe et conduit a` une difficulte : comment
definir un compte remunere sans decouvert ou un compte avec decouvert possible mais non remunere.
Il faudrait dans ce cas dupliquer a` la main ces classes pour les particulariser ; il nest pas difficile
dimaginer lensemble des modifications quentranerait cette solution sur les programmes utilisant la
classe CompteBancaire.
Les langages de programmation modernes offrent differentes solutions a` ce probl`eme ; le but est
chaque fois de permettre une extension ou une specialisation des types de base. Avec la programmation par objets ceci se realise naturellement avec la notion dh eritage. Le principe consiste a` definir
une nouvelle classe a` partir dune classe existante en ajoutant des donnees a` cette classe et en
reutilisant de facon implicite toutes les donnees de la classe de base. Si A est la classe de base et si
B est la classe construite a` partir de A on dit que B herite de A ou encore que B specialise A
ou encore que B derive de A. On dira e galement que A est la classe m`ere de B et que B est une
sous-classe, ou une classe fille de A. Dans le cas o`u une classe herite dune seule classe (cest le
cas en Java) on parle dheritage simple (au lieu dheritage multiple) et la relation m`ere-fille definit un
arbre comme represente par le dessin suivant o`u B1 et B2 heritent de A et o`u C herite de B1 (et donc
e galement par transitivite de A). On notera quen Java toute classe herite de la classe Object.
A

B1

B2

F IG . 16.1 Hierarchie de classes

Pour e tre plus precis, lors de la construction dune nouvelle classe par extension dune classe
existante, on distingue trois sortes de methodes (ou de variables) :
les methodes (et les variables) qui sont propres a` la nouvelle classe ; il sagit l`a dextension. Ces
methodes (donnees) nexistent que pour les objets de la nouvelle classe et portent un nom qui
nest pas utilise dans la classe m`ere ou, un nom dej`a utilise mais avec des param`etres en nombre
ou de type differents (il y a alors une surcharge du nom de la methode).
les methodes (et les variables) qui sont issues de la classe m`ere ; il sagit l`a dheritage. Ces
methodes (donnees) sont les meme pour les objets de la classe m`ere et pour les objets de la
classe heritee. Par defaut, toute methode (variable) est heritee. On notera que lors de lutilisation
dune methode heritee sur un objet de la classe fille il y a une conversion implicite de lobjet de
la classe fille en un objet de la classe m`ere. Le code dune methode (ou la donnee) heritee est
soit partage lorsque la methode est statique soit propre a` chaque instance dans le cas contraire
(cas par defaut).
les methodes (ou les variables, mais cela est plus rare) qui redefinissent des methodes (variables)
existantes dans la classe m`ere ; il sagit l`a de masquage. Ces methodes ont le meme nom et
le meme profil (nombre et type des param`etres, valeur de retour) que les methodes quelles
redefinissent. Dans ce cas, la nouvelle methode se substitue a` la methode de la classe m`ere.

CHAPITRE 16. HERITAGE

Ceci permet de prendre en compte lenrichissement (ou la specialisation) que la classe fille
apporte par rapport a` la classe m`ere en specialisant le code de la methode. Lorsque dans une
classe derivee on souhaite designer une methode (ou une donnee) de la classe m`ere (et en
particulier lorsque celle-ci est masquee) on designe celle-ci en prefixant le nom de la methode
(ou de la variable) par super. Ainsi, si B derive de A et si x est un nom utilise dans A et B, la
denomination super.x dans une methode de B designera x relatif a` A et non x relatif a` B (qui
serait designe par this.x). Dans le cas particulier du constructeur, un appel a` super designe
un appel au constructeur approprie (celui dont le nombre et le type des param`etres conviennent)
de la classe m`ere.
La syntaxe utilisee en Java pour definir quune classe B e tend une classe A consiste a` preciser lors
de la declaration de la nouvelle classe cette extension avec la notation class B extends A. Tout
ce qui sera defini au niveau de cette nouvelle classe B sera propre a` B ; tout ce qui nest pas redefini
sera herite de A, cest-`a-dire quun objet instance de B pourra acceder a` ces donnees ou methodes
comme un objet instance de A.
Appliquons ces principes a` la construction de deux classes derivees de la classe CompteBancaire.
La premi`ere permettra de representer des comptes bancaires avec decouvert autorise ; la seconde prendra en compte une possible remuneration du compte. Pour le premier type de compte, il faut preciser
quel est le decouvert maximum autorise. Pour le second type de compte, il faudra definir quel est la
remuneration (taux) et, par exemple, quel est le seuil minimal a` partir duquel la remuneration sapplique.

16.3 Extension de la classe CompteBancaire en CompteAvecDecouvert

Pour cette nouvelle classe nous introduisons une nouvelle donnee : le montant maximum du
decouvert. Cela nous conduit a` modifier la methode retrait de telle sorte quun retrait puisse e tre
effectuer meme si le solde nest pas suffisant (il faudra neanmoins que le solde reste plus grand que
loppose du decouvert maximal autorise). Cette methode retrait masquera la methode de meme
nom de la classe m`ere. Par ailleurs, on introduira une nouvelle methode fixeDecouvertMaximal
qui permet de modifier le montant du decouvert maximum autorise. Les autres donnees et methodes
seront reprises telles quelles (par le mecanisme dheritage). Pour la definition du constructeur on utilise le constructeur de la classe m`ere (par un appel a` super). Notons que super est toujours appele
dans un constructeur soit de mani`ere implicite en debut dexecution du constructeur soit de mani`ere
explicite par un appel a` super.
p u b l i c c l a s s CompteAvecDecouvert e x t e n d s C o m p t e B a n c a i r e {
double d e c o u v e r t M a x ;
p u b l i c v o i d f i x e D e c o u v e r t M a x i m a l ( double m o n t a n t ) {
t h i s . decouvertMax = montant ;
}
p u b l i c CompteAvecDecouvert ( S t r i n g p r o p r i o ,
char [ ] num ,
double m o n t a n t ,
double d e c o u v e r t M a x ) {
super ( p r o p r i o , num , m o n t a n t ) ;
t h i s . decouvertMax = decouvertMax ;
}

16.4. EXTENSION DE LA CLASSE COMPTEBANCAIRE EN COMPTEAVECREMUNERATION 5

p u b l i c v o i d r e t r a i t ( double m o n t a n t )
throws p r o v i s i o n I n s u f f i s a n t e E r r e u r {
System . o u t . p r i n t l n ( Appel de r e t r a i t s u r compte a v e c d e c o u v e r t ) ;
i f ( t h i s . s o l d e montant < decouvertMax ){
throw new p r o v i s i o n I n s u f f i s a n t e E r r e u r ( ) ;
}else{
s o l d e = m o n t a n t ;
}
}
}

On peut alors completer le programme de test par les instructions suivantes :

CompteAvecDecouvert d1 ;
S t r i n g num4 = DD545AA54 ;
d1 = new CompteAvecDecouvert ( J a c q u e s , num4 . t o C h a r A r r a y ( ) ,
6000.00 , 0.00) ;
try {
d1 . r e t r a i t ( 7 0 0 0 . 0 0 ) ;
System . o u t . p r i n t l n ( r e t r a i t b i e n p a s s e e ; +
nouveau s o l d e = + d1 . s o l d e C o u r a n t ( ) ) ;
} catch ( Exception e )
{ System . o u t . p r i n t l n (
Un p r o b l e m e e s t s u r v e n u l o r s du p r e m i e r r e t r a i t ) ; } ;
d1 . f i x e D e c o u v e r t M a x i m a l ( 2 0 0 0 . 0 0 ) ;
try {
d1 . r e t r a i t ( 7 0 0 0 . 0 0 ) ;
System . o u t . p r i n t l n ( r e t r a i t b i e n p a s s e e ; +
nouveau s o l d e = + d1 . s o l d e C o u r a n t ( ) ) ;
} catch ( Exception e )
{ System . o u t . p r i n t l n (
Un p r o b l e m e e s t s u r v e n u l o r s du s e c o n d r e t r a i t ) ; } ;
d1 . d e p o t ( 5 0 0 0 . 0 0 ) ;

16.4 Extension de la classe CompteBancaire en CompteAvecRemuneration

Pour cette extension, il faut au minimum connaitre le taux de remuneration du compte a` partir
duquel la remuneration sapplique. On suppose que les interets sont verses a` part et integres sur le
compte une fois lan. Afin de simplifier lecriture de cette classe nous supposerons quil existe une
methode qui calcule les interets (le code est un peu complexe et necessite la connaissance des dates
auquelles sont faites les operations afin de calculer les durees pendant lesquels linetret sapplique).
p u b l i c c l a s s CompteRemunere e x t e n d s C o m p t e B a n c a i r e {
double t a u x ;
double i n t e r e t s ;
p u b l i c v o i d f i x e T a u x ( double m o n t a n t ) {
t h i s . taux = montant ;


CHAPITRE 16. HERITAGE

6
}

p u b l i c CompteRemunere ( S t r i n g p r o p r i o , char [ ] num , double m o n t a n t ,

double t a u x ) {
super ( p r o p r i o , num , m o n t a n t ) ;
fixeTaux ( montant ) ;
interets = 0.0;
}
p u b l i c v o i d r e t r a i t ( double m o n t a n t )
throws p r o v i s i o n I n s u f f i s a n t e E r r e u r {
System . o u t . p r i n t l n ( Appel de r e t r a i t s u r compte r e m u n e r e ) ;
i f ( t h i s . solde < montant ){
throw new p r o v i s i o n I n s u f f i s a n t e E r r e u r ( ) ;
}else{
s o l d e = m o n t a n t ;
}
}
public void c a l c u l I n t e r e t ( ) {
i n t e r e t s + = 1 . 0 ; / / bien sur , l e code r e e l e s t p l u s complexe
}
}

On peut alors definir un compte remunere avec decouvert autorise. Il suffit pour cela de deriver de
la classe CompteRemunere la classe CompteRemunereAvecDecouvert. Cela se fait simplement de la facon suivante (il suffit dintroduire une nouvelle variable et un nouveau constructteur et
de redefinir la methode de retrait) :
p u b l i c c l a s s CompteRemunereAvecDecouvert e x t e n d s CompteRemunere {
double d e c o u v e r t M a x ;
p u b l i c v o i d f i x e D e c o u v e r t M a x i m a l ( double m o n t a n t ) {
t h i s . decouvertMax = montant ;
}
p u b l i c CompteRemunereAvecDecouvert ( S t r i n g p r o p r i o ,
char [ ] num ,
double m o n t a n t ,
double t a u x ,
double d e c o u v e r t M a x ) {
super ( p r o p r i o , num , m o n t a n t , t a u x ) ;
/ / i c i s u p e r d e s i g n e l a c l a s s e CompteRemunere
fixeDecouvertMaximal ( decouvertMax ) ;
}
p u b l i c v o i d r e t r a i t ( double m o n t a n t )
throws p r o v i s i o n I n s u f f i s a n t e E r r e u r {
System . o u t . p r i n t l n (
Appel de r e t r a i t s u r compte r e m u n e r e a v e c d e c o u v e r t ) ;
i f ( t h i s . s o l d e montant < decouvertMax ){
throw new p r o v i s i o n I n s u f f i s a n t e E r r e u r ( ) ;

16.4. EXTENSION DE LA CLASSE COMPTEBANCAIRE EN COMPTEAVECREMUNERATION 7

}else{
s o l d e = m o n t a n t ;
}
}
}

On obtient alors larbre de classes suivant :

CompteBancaire

CompteAvecDecouvert

CompteRemunere

CompteRemunereAvecDecouvert

F IG . 16.2 Hierarchie des classes definies dans ce cours

Cette nouvelle classe peut e tre utilisee de la facon suivante :
dd = new CompteRemunereAvecDecouvert ( P i e r r e , num5 . t o C h a r A r r a y ( ) ,
6000.00 , 0.00 , 0.05) ;
dd . d e p o t ( 1 0 0 0 . 0 0 ) ;
try {
dd . r e t r a i t ( 8 0 0 0 . 0 0 ) ;
System . o u t . p r i n t l n (
r e t r a i t 1 b i e n p a s s e e s u r dd ; nouveau s o l d e =
+ dd . s o l d e C o u r a n t ( ) ) ;
} catch ( Exception e )
{ System . o u t . p r i n t l n (
Un p r o b l e m e e s t s u r v e n u l o r s d un r e t r a i t ) ; } ;
dd . f i x e D e c o u v e r t M a x i m a l ( 2 0 0 0 . 0 0 ) ;
try {
dd . r e t r a i t ( 8 0 0 0 . 0 0 ) ;
System . o u t . p r i n t l n (
r e t r a i t 2 b i e n p a s s e e s u r dd ; nouveau s o l d e =
+ dd . s o l d e C o u r a n t ( ) ) ;
} catch ( Exception e )
{ System . o u t . p r i n t l n (
Un p r o b l e m e e s t s u r v e n u l o r s d un r e t r a i t ) ; } ;
dd . d e p o t ( 5 0 0 0 . 0 0 ) ;
dd . f i x e T a u x ( 0 . 0 6 ) ;

On notera que, la methode retrait utilisee lors de ces instructions est celle qui est redefinie dans
la nouvelle classe. La methode fixeTaux est par contre la methode herite de la classe CompteRemunere


CHAPITRE 16. HERITAGE

et les methodes depot et soldeCourant sont celles heritees de la classe m`ere CompteBancaire.
On le voit, lheritage est transitif.

16.5 Transtypage, classe declaree et classe dexecution

En programmation fortement typee le melange des types nest permis quavec le respect de r`egles
strictes. Il est par exemple interdit daffecter une valeur reelle a` une variable booleenne. Il existe
neanmoins des possibilites de convertir une valeur dun type donnee en une valeur dun autre type ; on
parle de transtypage ou de conversion de type (cast). Cette conversion peut e tre implicite lorsquelle
est fait automatiquement par le compilateur (conversion directe ou insertion de code de conversion)
ou explicite par lemploi dune notation appropriee. Ce mecanisme a dej`a e te e tudie en debut dannee
pour les types e lementaires de Java.
La r`egle liee a` la programmation objet est que toute classe est compatible avec ses sous-classes
cest a` dire que si B est une sous-classe de A alors toute variable de type A peut e tre affectee par une
valeur de type B (par une instruction daffectation ou lors dun passage de param`etre). Par exemple,
si c1 est un compte bancaire et si d1 est un compte bancaire avec decouvert autorise alors laffectation c1 = d1 est correcte. Par contre, laffectation d1 = c1 sera incorrecte. De meme une instruction
c1.virement(d1, 100.0) sera correcte et il y aura une conversion implicite de d1 en une valeur de type compteBancaire lors de lappel de la methode virement. On peut bien entendu
e galement executer linstruction d1.virement(c1, 100.0).
Lors de lappel c1.virement(d1, 100.0), le param`etre formel de la methode virement
designant le compte sur lequel on va operer un retrait (nommons le c) est associe au param`etre effectif d1. Une conversion a lieu. Cependant, c qui est de classe declaree CompteBancaire sera
de classe reelle CompteAvecDecouvert lors de lexecution de cet appel (il restera associe au
param`etre effectif d1 qui est une instance de la classe CompteAvecDecouvert. Ainsi, linstruction c1.retrait(montant) de cette methode fera appel a` la methode retrait de la classe
CompteAvecDecouvert qui est la classe reelle de c lors de cet appel. Par contre, lappel de
d1.virement(c1, 100.0), conduit a` un appel de la methode methode retrait de la classe
CompteBancaire car cette fois-ci, le param`etre formel c est associe a` la variable c1 qui est un objet
de la classe CompteBancaire et donc, la classe reelle de c lors de cette execution est CompteBancaire.
Les instructions suivants permettent de visualiser ces principes (les methodes retrait affichent des
messages differents).
d1 . d e p o t ( 5 0 0 0 . 0 0 ) ;
try {
c1 . v i r e m e n t ( d1 , 1 0 0 0 . 0 0 ) ;
d1 . v i r e m e n t ( c1 , 1 0 0 0 . 0 0 ) ;
} catch ( Exception e )
{ System . o u t . p r i n t l n (
Un p r o b l e m e e s t s u r v e n u l o r s d un v i r e m e n t ) ; } ;

16.6 Liaison dynamique

Dans les exemples precedents, les methodes appelees a` lexecution du programme sont connues a`
la compilation.
Supposons maintenant que lon declare un compte bancaire c sans linitialiser :

16.6. LIAISON DYNAMIQUE

CompteBancaire c ;
S t r i n g num = AAA4AA54 ;

Les r`egles de typages de Java font quil est possible dassocier a` c par creation un compte ordinaire
ou un compte avec decouvert. En effet, toute classe est compatible avec ses sous-classes, et donc, c
qui est de la classe CompteBancaire est compatible avec la classe CompteAvecDecouvert.
Les deux instructions
c = new C o m p t e B a n c a i r e ( Marie , num . t o C h a r A r r a y ( ) , 1 0 0 0 0 . 0 0 ) ;
c = new CompteAvecDecouvert ( Marie , num . t o C h a r A r r a y ( ) , 1 0 0 0 0 . 0 0 , 0 . 0 ) ;

sont donc correctes ; dans le premier cas, c sera de classe reelle CompteBancaire et dans le
second cas de classe reelle CompteAvecDecouvert. Donc, linstruction c.retrait(100.00)
appelera soit la methode retrait des comptes avec decouvert (second cas) soit la methode retrait
des comptes ordinaires. Cette liaison entre appel et methode peut se faire lors de la compilation (dans
le cas o`u le compilateur a suffisamment dinformations pour calculer cette liaison) ou simplement
lors de lexecution du programme ; on parle alors de liaison tardive. La suite dinstructions suivantes
illustre ce mecanisme : selon la reponse faite par lutilisateur, le programme associe a` c un compte
ordinaire ou un compte avec decouvert.
public clas s TestLiaisonTardive{
p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
CompteBancaire c ;
S t r i n g num = AAA4AA54 ;
T e r m i n a l . e c r i r e S t r i n g ( Voulez vous c r e e r un compte d e c o u v e r t O/ N : ) ;
char r e p o n s e ;
reponse = Terminal . l i r e C h a r ( ) ;
i f ( ( r e p o n s e ! = O ) & & ( r e p o n s e ! = o ) ) {
T e r m i n a l . e c r i r e S t r i n g ( C r e a t i o n d un compte o r d i n a i r e ) ;
c = new C o m p t e B a n c a i r e ( Marie , num . t o C h a r A r r a y ( ) , 1 0 0 0 0 . 0 0 ) ;
}
else {
T e r m i n a l . e c r i r e S t r i n g ( C r e a t i o n d un compte a v e c d e c o u v e r t ) ;
T e r m i n a l . e c r i r e S t r i n g ( Quel e s t l e c o u v e r t maximal e a u t o r i s : ) ;
double max ;
max = T e r m i n a l . l i r e D o u b l e ( ) ;
c = new CompteAvecDecouvert ( Marie , num . t o C h a r A r r a y ( ) , 1 0 0 0 0 . 0 0 , max ) ;
}
System . o u t . p r i n t l n ( s o l d e a v a n t r e t r a i t

+ c . soldeCourant ( ) ) ;

try {
System . o u t . p r i n t l n ( T e n t a t i v e de r e t r a i t de 1 1 0 0 0 . 0 0 ) ;
c . r e t r a i t (11000.00);
System . o u t . p r i n t l n ( l e r e t r a i t c e s t b i e n p a s s e e ; nouveau s o l d e =
+ c . soldeCourant ( ) ) ;


CHAPITRE 16. HERITAGE

10

}
catch ( Exception e )
{ System . o u t . p r i n t l n ( Un p r o b l e m e e s t s u r v e n u l o r s du r e t r a i t ) ; }
}
}

16.7 Droits dacc`es

Pour terminer ce chapitre detaillons les facons de permettre ou dinterdire lacc`es aux methodes
ou aux variables dune classe grace aux mots clefs public, private, protected utlises lors de
leur declaration.
Lorsquune methode, une variable (ou une classe) est marquee public (comme par exemple
public int x;) elle est accessible (et donc utlisable) a` partir de nimporte quelle autre methode
de nimporte quelle classe. Lorsquune methode ou une variable est marquee private elle nest accessible qu`a linterieur de la classe o`u elle definie. Lorsquune ou une variable est marquee protected
elle est utilisable a` linterieur de la classe o`u elle definie et aussi par toutes les methodes des classes
derivees de cette classe.
Enfin, si rien nest precise, la classe, la methode ou la variable est accessible par toute methode de
toute classe du meme paquetage (mani`ere de regrouper des classes en Java).