je suis conent

1. Java : Introduction
Master PISE
Cours, Partie 4
Package et Héritage
1 / 20

2. Packages
• Packages
• Niveaux de Protection
Les packages permettent d’organiser des bibliothèques de classes Java. Cela
• Héritage : intro permet notamment de regrouper sous un meme debut de nom des classes
• Héritage
apparentées. Cela permet aussi d’offrir un niveau de protection particulier à un
groupe de classes.
Le package standard, celui qui est utilisé par le compilateur lorsqu’on ne lui
demande rien de plus, est le package java.lang. Il contient par exemple les
classes Math (la classe la plus générale), String .... (allez faire un tour sur le
site).
Le nom complet des classes est en fait java .lang.Math ou java.lang.String.
Den nombreux autres packages existent et sont fournis dans le JDK. Par
exemple :
java.applet, java.awt, java . io ....
2 / 20

3. Package - import
• Packages
• Niveaux de Protection
• Héritage : intro Si on veut utiliser par exemple la classe Applet dans le package java.applet, on
• Héritage
peut taper son nom complet : java.applet.Applet
On peut aussi plus simlplement utiliser la directive import java.applet.Applet;
Ensuite, il n’est plus nécessaire de taper le nom complet, il suffit de taper Applet.
Lorsque l’on veut pouvoir utiliser plusieurs classes d’un mêmes package, on
peut utiliser la commande import java.applet.∗;
Les directives import doivent apparaître en têtre du fichier .java.
3 / 20

4. Niveaux de Protection
• Packages
• Niveaux de Protection
L’ encapsulation est le principe qui permet de regrouper les attributs et les
• Héritage : intro méthodes au sein d’une classe. Cette notion est aussi associée à la protection
• Héritage
que l’on veut donner aux variables ou méthodes.
Java fournit pour cela des niveaux de protection différents.
• public : accessible sans restriction
• private : accessible que dans les méthodes de la classe.
• ( rien ) : public depuis tout le package, mais private par rapport au reste
• protected : on oublie pour l’instant, lié à la notion d’héritage
Tout appel enfreignant ces règles génerera une erreur à la compilation.
4 / 20

5. Protection - pourquoi?
• Packages
• Niveaux de Protection
L’interêt de mettre un champ private est de permettre un controle sur la façon
• Héritage : intro dont il pourra être lu ou modifié.
• Héritage
Si l’on souhaite que l’utilisateur puisse lire ou modifier un champ private, il
faudra donc à chaque fois inclure dans la classe :
• une méthode publique pour récupérer la valeur du champ :
généralement get<Nomduchamp>
• ET/OU une méthode publique pour modifier la valeur du champ :
généralement set<Nomduchamp>
Cela permet de s’assurer que lorsque un champ est modifié c’est en respectant
certaines règles fixées.
Par exemple dans la classe Banque, on veut pouvoir éviter qu’une quelconque
opération puisse mettre le solde inférieur à 0. En mettant le champ private et
avec une méthode setSolde on peut s’arranger dans la définition de cette
méthode que la classe renvoie une erreur si l’on fait une telle chose.
5 / 20

6. Protections : Résumé - Conventions :
• Packages
• Niveaux de Protection
• Héritage : intro
• Héritage
• Une classe pourra etre (rien) ou public. Dans un fichier qui contient
plusieurs classes la seule contrainte est qu’il ne peut y avoir qu’une seule
classe publique et que ce doit être le nom du fichier.
• Les champs seront (sauf rares exceptions) toujours private et on munira
la classe au besoin de méthodes de modifications et d’accès.
• Les méthodes seront (presque toujours) publiques.
6 / 20

7. Protection - Exercice
• Packages
• Niveaux de Protection
Reprenez la classe Identite en respectant les règles d’encapsulation énoncées
• Héritage : intro précédemment. Tous les champs seront private et auront chacun une méthode
• Héritage
get .. et set ... permettant de fixer leur valeur.
7 / 20

8. Héritage : intro
• Packages
• Niveaux de Protection
Supposons que l’on veuille faire un programme gérant un parc de location de
• Héritage : intro véhicules. On aura besoin d’écrire une classe décrivant des voitures.
• Héritage
public class V o i t u r e {
Identite proprio ;
S tr i ng modele ;
i n t annee ;
i n t nbPortes ;
i n t vitesseMax ;
boolean c l i m a t i s e ;
}
8 / 20

9. Héritage : intro
• Packages
• Niveaux de Protection
On peut ensuite vouloir faire la meme chose pour les motos
• Héritage : intro
• Héritage
public class Moto {
Identite proprio ;
S tr i ng modele ;
i n t annee ;
i n t vitesseMax ;
boolean c o f f r e ;
}
9 / 20

10. Héritage : intro
• Packages
• Niveaux de Protection
Ou les vélos
• Héritage : intro
• Héritage
public class Velo {
Identite proprio
S tr i ng modele ;
i n t annee ;
i n t n b V it e s s e s ;
}
10 / 20

11. Héritage : intro
• Packages
• Niveaux de Protection
On se rend compte qu’il y a beaucoup de choses en commun qui sont dues au
• Héritage : intro fait que ces classes représentent toutes des véhicules. En java on peut écrire la
• Héritage
chose suivante pour rassembler ces caractéristiques communes :
public class V e h i c u l e {
Indentite proprio
S tr i ng modele ;
i n t annee ;
i n t nbRoues ;
}
11 / 20

12. Héritage : intro
• Packages
• Niveaux de Protection
Ensuite, on pourra alors utiliser la notion d’héritage pour écrire
• Héritage : intro
• Héritage
public class V e h i c u l e {
Indentite proprio
S tr i ng modele ;
i n t annee ;
i n t nbRoues ;
}
public class V o i t u r e extends V e h i c u l e {
i n t nbPortes ;
i n t vitesseMax ;
boolean c l i m a t i s e ;
}
public class Moto extends V e h i c u l e {
i n t vitesseMax ;
boolean c o f f r e ;
}
public class Velo extends V e h i c u l e {
i n t n b V it e s s e s ;
}
Ces classes disposeront des champs et des méthodes de la classe Vehicule,
même si ceux-ci n’apparaissent pas dans leur corps.
12 / 20

13. Héritage : intro
• Packages
• Niveaux de Protection
Ici, on a un exemple avec une profondeur de 1 mais on pourrait par exemple
• Héritage : intro envisager
• Héritage
public class V e h i c u l e {
Indentite proprio
S tr i ng modele ;
i n t annee ;
i n t nbRoues ;
}
public class Velo extends V e h i c u l e {
i n t n b V it e s s e s ;
}
public class V e h ic u le Mo t e ur extends V e h i c u l e {
i n t vitesseMax ;
}
public class V o i t u r e extends V e h ic u le Mo t eu r {
i n t nbPortes ;
boolean c l i m a t i s e ;
}
public class Moto extends V e h ic u le Mo t eu r {
boolean c o f f r e ;
}
13 / 20

14. Héritage
• Packages
• Niveaux de Protection
En Java, toute classe, sauf la classe Object, dérive d’une classe, qui s’appelle
• Héritage : intro sa ”superclasse”.
• Héritage
Une classe qui n’indique pas sa superclasse hérite automatiquement de la
classe Object.
Lorsque l’on écrit une classe, on annonce sa superclasse à l’aide du mot
extends en écrivant :
class B extends A{....}.
On dira alors que :
• B hérite de A.
• A est la superclasse de B.
• B est une sous-classe de A.
• B étend A.
14 / 20

15. Héritage
• Packages
• Niveaux de Protection
La sous-classe B :
• Héritage : intro
• Héritage • peut accéder aux membres publics de sa classe de base, comme s’ils
étaient écrits dans sa classe
• ne peut pas accéder aux membres privés.
• peut accéder aux membres protégés (protected) de sa classe de base.
En Java, une classe ne peut étendre qu’une seule classe, il n’y a pas d’héritage
multiple.
On peut interdire qu’une classe soit étendue, il suffit pour cela de lui ajouter le
modificateur final :
final class A {...}
15 / 20

16. Héritage - Constructeurs
• Packages
• Niveaux de Protection
Suposons que B soit une sous-classe de A.
• Héritage : intro Dans la définition d’un constructeur de la classe B, on peut vouloir faire appel au
• Héritage
constructeur de la superclasse A pour remplir par exemple les champs hérités,
avant d’initialiser les champs spécifiques à B. On utilisera alors le mot super qui
désigne le constructeur de la superclasse. Attention, Java impose que cet appel
soit la première instruction du constructeur de B.
class P o i n t {
private int x , y ;
public P o i n t ( x , y ) {
t h i s . x=x ; t h i s . y=y ;
}
}
class P o i n t C o l o r e extends P o i n t {
p r i v a t e byte c o u l e u r ;
public P o i n t C o l o r e ( i n t x , i n t y , byte c ) {
super ( x , y ) ;
t h i s . c o u l e u r=c ;
}
}
16 / 20

17. Héritage - Méthodes et redéfinition
• Packages
• Niveaux de Protection
Si l’on dispose d’une méthode dans A, on peut l’utiliser sur un objet de la
• Héritage : intro sous-classe B sans la réécrire.
• Héritage
On peut aussi rédéfinir le comportement d’une méthode, c’est à dire réécrire
dans la sous-classe une méthode de mêmes nom ET de signature (nombre et
types d’arguments et type de sortie).
Lorsque l’on fait ceci, pour un objet de type B, c’est cette méthode qui sera
appelée et non plus celle de la superclasse.
class P o i n t {
private int x , y ;
...
public void a f f i c h e ( ) {
System . o u t . p r i n t l n ( " Je s u i s en " + x + " " + y )
}
}
class P o i n t C o l o r e extends P o i n t {
p r i v a t e byte c o u l e u r ;
...
public void a f f i c h e ( ) {
System . o u t . p r i n t l n ( " Je s u i s en " + x + " " + y ) ;
System . o u t . p r i n t l n ( "ma c o u l e u r e s t " + c ) ;
}
}
17 / 20

18. Héritage - Méthodes et redéfinition
• Packages
• Niveaux de Protection
Dans l’exemple précédent on pourrait être tenté d’utiliser la méthode affiche de
• Héritage : intro la super classe et d’écrire
• Héritage
class P o i n t C o l o r e extends P o i n t {
...
public void a f f i c h e ( ) {
affiche ( ) ;
System . o u t . p r i n t l n ( "ma c o u l e u r e s t " + c ) ;
}
}
Si on fait cela on provoque un appel récursif et un plantage. Il faut pouvoir
préciser qu’on parle de la méthode affiche de la superclasse. On utilise pour
cela le mot clef super.
public void a f f i c h e ( ) {
super . a f f i c h e ( ) ;
System . o u t . p r i n t l n ( "ma c o u l e u r e s t " + c ) ;
}
18 / 20

19. Héritage - Polymorphisme
• Packages
• Niveaux de Protection
Ce genre d’appel est illégal :
• Héritage : intro
• Héritage
P o i n t C o l o r e pc = new P o i n t ( 3 , 5 ) ;
en effet, on se doute que cela pourrait poser des problèmes lorsque l’on essaie
d’accéder à la couleur de pc.
En revanche, Jave autorise l’inverse :
P o i n t p = new P o i n t C o l o r e ( 3 , 5 , ( byte ) 2 )
Dans ce cas si on applique la méthode affiche à p, il va utiliser la version qui
est contenue dans la classe PointCol. Autrement dit l’instruction ne se fonde
pas sur le type de la variable p, mais bien sur le type effectif de l’objet référencé
par p au moment de l’appel.
p. affiche ()
va renvoyer
Je s u i s en 3 5
ma c o u l e u r e s t 2
19 / 20

20. Héritage - Polymorphisme
• Packages
• Niveaux de Protection
Si on est dans le cas précédent :
• Héritage : intro
• Héritage
P o i n t p = new P o i n t C o l o r e ( 3 , 5 , ( byte ) 2 )
on peut vouloir récupérer l’objet de type PointColore pointé par p dans une
référence du bon type.
On NE pourra PAS écrire
P o i n t C o l o r e pc = p ;
cela proquerait une erreur, il faudra alors écrire
P o i n t C o l o r e pc = ( P o i n t C o l o r e ) p ;
On parle de transtypage.
Il faudra bien faire attention à ce genre d’appel, cela signifie en gros qu’on dit à
Java "ne t’inquietes pas je m’assure que cette référence p contient bien ce qu’il
faut". Si jamais à l’éxécution il s’avère que ce n’est pas le cas cela provoquera
bien sur une erreur.
20 / 20