Programmation Orientée Objet : Concepts d'Héritage

Hé it
►
Hé
r
it
a
g
e
Introduction
La notion d
'
abstraction de réutilisation se traduit par :
La
notion
d abstraction
,
de
réutilisation
se
traduit
par
:
La notion de classe
"moule" de construction permettant de créer des objets d'un certain type
La notion d'agrégation
Exemple : la classe Rectangle utilise le concept de Point dans sa définition
=> définition avec un plus haut niveau d'abstraction
La notion d'héritage
Spécialisation d'un concept
Une classe dérivée
adopte,
spécialise
@
irisa.fr
spécialise
et/ou enrichit
les membres (structure, méthode) d'une classe de base
eric.anquetil
@
62
Hiérarchisation des concepts

Héritage : diagramme de classe (Personne /employe)
Diagramme de classes
Diagramme
de
classes
Membre
ajouté
Méthode
spécialisée
spécialisée
Méthode
remplacée
@
irisa.freric.anquetil
@
63
Héritage : la classe Personne
La classe Personne
La
classe
Personne
public class
Personne
{
public
class
Personne
{
private int _age;
private String _nom;
public int age() { return _age;}
public String nom() { return _nom;}
public void miseAJour(int a,String n){
_nom=n;
_age=a;
public Personne (int a, String n) {
_age=a;
nom=n;
}
public String toString() {
return ("Personne : "+_nom+" : "+
_nom=n;
}
public Personne (Personne p) {
age=p age;
_age);
}
… }
@
irisa.fr
_age=p
._
age;
_nom=p._nom;
}
eric.anquetil
@
64

Héritage : constructeur / extends
Déclaration de l
’
héritage
Déclaration
de
l héritage
Le mot clé utilisé pour signifier l’héritage : «extends»
En Java on ne peut hériter que d’une seule classe à la fois
Constructeur
Le constructeur de la classe
public class Employe extends Personne {
private int _salaire;
de base (ici Personne) est appelé
par l’instruction « SUPER »
«super» doit être la
public Employe (int a, String n, int s) {
super(a,n);
_salaire=s;
1ère instruction }
public Employe (Personne p, int salaire) {
super(p);
Le(s) constructeur(s) d’une
classe dérivée devront faire
l() tt()
_salaire=salaire;
}
…
}
@
irisa.fr
appe
l
au
(
x
)
cons
t
ruc
t
eur
(
s
)
de la classe de base :
implicitement (utilisation du constructeur par défaut)
li it t ( )
}
eric.anquetil
@
65
ou exp
li
c
it
emen
t
(
super …
)
Héritage : des attributs et des méthodes
La classe dérivée hérite automatiquement
La
classe
dérivée
hérite
automatiquement
des attributs et des méthodes de la classe de base
public class Employe extends Personne {
private int _salaire;
…
public Employe (Personne p, int salaire) {
public class Personne {
private int _age;
p
rivate Strin
g
_
nom;
super(p);
_salaire=salaire;
}
bli
El
(i t St i i t ) {
pg_
public int age(){return _age;}
public String nom(){return _nom;} pu
bli
c
E
mp
l
oye
(i
n
t
a,
St
r
i
ng n,
i
n
t
s
)
{
super(a,n);
_salaire=s;
}
…
public Personne (Personne p) {
_age=p._age;
}
public static void main(String[] args){
Personne p1=new Personne
(
29, "toto"
)
;
_
nom=p._nom;
}
…
}
@
irisa.fr
()
Employe e2=new Employe(p1,4000);
Employe e3=new Employe(20,"titi",1000);
System.out.println(e2.nom());
System out println(
e3 age
());
}
eric.anquetil
@
66
System
.
out
.
println(
e3
.
age
());
…
}

Héritage : enrichissement d'une méthode
Super
Permet d'invoquer le constructeur de la classe de base
Permet d'accéder aux membres de la classe de base
p
ublic class Em
p
lo
y
e extends Personne
{
p
ublic class Personne
{
p
py
{
private int _salaire;
…
public Employe (Personne p, int salaire) {
p
{
private int _age;
private String _nom;
bli i t
(){ t }
super(p);
salaire=salaire;
}
public void
miseAJour
(int a String n int s)
{
pu
bli
c
i
n
t
age
(){
re
t
urn _age;
}
public String nom(){return _nom;}
…
public
Personne
(Personne p) {
public
void
miseAJour
(int
a
,
String
n
,
int
s)
{
miseAJour(a,n); // pas ambiguïté
salaire=s;
}
public
Personne
(Personne
p)
{
_age=p._age;
_nom=p._nom;
}
public void miseAJour() { // enrichissement
super.miseAJour(); // ambiguïté levée
salaire=0;
}
}
public void miseAJour(int a,String n) {
_nom=n;
_age=a;
}
@
irisa.fr
}
public static void main(String[] args){
Personne p1=new Personne(29, "toto");
Employe e2=new Employe(p1,4000);
}
public void miseAJour(){
_nom="*";
_age=0;
}
eric.anquetil
@
67
e2.miseAJour(e2.age(),e2.nom(),6000);
e2.miseAJour(); System.out.println(e2);
…
}}
}
…
}
Héritage : redéfinition d'une méthode
Redéfinition (
surcharge)
Redéfinition
(
surcharge)
Une méthode est redéfinie si elle possède la même signature
(nom + type des paramètres) et le même type de retour que dans la classe de
base
base
public class Employe extends Personne {
private int _salaire;
public class Personne {
private int _age;
itSti
…
public Employe (Personne p, int salaire) {
super(p);
salaire=salaire;
pr
i
va
t
e
St
r
i
ng _nom;
public int age(){return _age;}
public String
nom
(){return nom;}
_salaire=salaire;
}
public String toString() {
return (
"
Employe :
"+
nom()
+"
:
"+
public
String
nom
(){return
_
nom;}
…
public Personne (Personne p) {
age
=
p age;
return
(Employe
:
nom()
:
age()+" / "+ _salaire);
}
public static void main(String[] args){
Personne p1=new Personne(29 "toto");
_age p
._
age;
_nom=p._nom;
}
public String toString() {
@
irisa.fr
Personne
p1=new
Personne(29
,
"toto");
System.out.println(p1); // toString de Personne
Employe e2=new Employe(p1,4000);
System out println(e2);
// toString de Employe
return ("Personne : "+_nom+" : "
+_age);
}
…
eric.anquetil
@
68
System
.
out
.
println(e2);
//
toString
de
Employe
…
}
}

Héritage : redéfinition et attachement dynamique
La redéfinition est
p
articulièrement intéressante
q
uand elle est utilisée avec la
pq
notion d’attachement dynamique / Polymorphisme
L’attachement dynamique (mécanisme implicite de Java) permet à la JVM de choisir la
bonne méthode en fonction du type réel (de la classe) de l'objet appelant
public class Employe extends Personne {
private int _salaire;
public class Personne {
private int _age;
iSi
…
public Employe (Personne p, int salaire) {
super(p);
salaire=salaire;
pr
i
vate
S
tr
i
ng _nom;
…
public Personne (Personne p) {
age
=
p. age;
_salaire=salaire;
}
public String type() {
return "Em
p
lo
y
e";
_age p.
_
age;
_nom=p._nom;
}
public String type() {
return "Personne";
py
}
public static void main(String[] args){
Personne p1=new Personne(29, "toto");
E l 2 E l ( 1 4000)
return
"Personne";
}
…
}
type de e2 : Employe
type de p1 : Personne
td3El
@
irisa.fr
E
mp
l
oye e
2
=new
E
mp
l
oye
(
p
1
,
4000)
;
Personne p3=e2;
System.out.println("type de e2 : "+e2.type());
System out println(
"
type de p1 :
"
+p1
type
());
t
ype
d
e p
3
:
E
mp
l
oye
@
Obj pers
p1: Réf sur Pers.
eric.anquetil
@
69
System
.
out
.
println( type
de
p1
:
+p1
.
type
());
System.out.println("type de p3 : "+p3.type());
…
}
Obj emp
@
@p3: Réf sur Pers.
e2: Réf sur Empl.
Héritage : exemple d'exploitation de l’attachement dynamique
Utilisation d'un tableau de <Personne>
Nb: les <Employe> sont aussi des <Personne>
On met dans le tableau des objets de type <Employe> et <Personne>
L’attachement dynamique permet de manipuler les éléments du tableau de personnes
en fonction de leur classe !
en
fonction
de
leur
classe
!
public class Employe extends Personne {
private int _salaire;
bli l
P
{
…
public String type() {
return "Employe";
}
pu
bli
c c
l
ass
P
ersonne
{
private int _age;
private String _nom;
}
public static void main(String[] args){
Personne p1=new Personne(29, "toto");
Personne p2=new Personne(27, "tata");
public int age(){return _age;}
public String nom(){return _nom;}
…
Employe e1=new Employe(29, "titi",7000);
Personne[] tabPers= new Personne[3];
tabPers[0]=p1;
tbP [1] 2
…
public String type() {
return "Personne";
}
@
irisa.fr
t
a
bP
ers
[1]
=p
2
;
tabPers[2]=e1;
for (int i=0; i< tabPers.length; i++) {
System out println(
tabPers[i]
+
"
/type=
"
…
}
Personne : toto : 29 / type = Personne
eric.anquetil
@
70
System
.
out
.
println(
tabPers[i]
+
/
type
=
+ tabPers[i].type() );
}…
}
Personne : tata : 27 / type = Personne
Employe : titi : 29 / 7000 / type = Employe