CHAPITRE

L’HERITAGE
 Objectifs
 
o Construire une super-classe.
o Construire une classe dérivée.
o Utiliser le polymorphisme et le
surcharge.
 L’HERITAGE
•  L'héritage de classes permet de définir une
hiérarchie de classe qui se compose de super
classes et de sous-classes. Une classe qui hérite
d'une autre est une sous-classe et celle dont elle
hérite est une super classe.

•  Une classe peut avoir plusieurs sous-classes.

•  Une classe ne peut avoir qu'une seule classe mère :

il n'y a pas d'héritage multiple en Java.
 HÉRITAGE
•  Nous pourrons créer des classes héritées (aussi
appelées classes dérivées ou sous-classe ) de nos
classes mères (aussi appelées classes de base ou classe
parente ou super-classe).

•  Lors de l'instanciation d'une classe dérivées , celle-ci

hérite de l'ensemble des propriétés et des méthodes de
sa superclasse,
 HÉRITAGE
•  Pour créer une nouvelle classe, nommée Capitale,
héritée de Ville.
•  Un objet Capitale aura tous les attributs et méthodes
associés objet Ville !

class Capitale extends Ville {
…
}
•  C'est le mot clé extends qui informe Java que la
classe Capitale est héritée de Ville
 HÉRITAGE
•  Remplacer private par protected dans la
déclaration de variables ou de méthodes
de la classe Ville aura pour effet de les
protéger des utilisateurs de la classe tout en
permettant aux objets enfants d'y accéder.
 Classe  de  base

Personne

Nom
Prénom

Age

Adresse
•  Une personne contient un nom ,
prenom, age et adresse
afficher()
•  La classe Employé
Un employé est une personne qui
extends
travaille dans une société.
Employe
les données de l’ Employé

correspond donc à celles de la
Société classe Personne.
salaire


Un employé a en plus la société a
laquelle il est rattaché ainsi qu’un

afficher() salaire.

Classe  dérivee

public    class  Personne{    
protected  String  nom;
 protected    String  prenom;    
 protected    int  age;    
 protected    String  ville;
 Personne(){};    
public  Personne(String    nom,  String    prenom,  int  age,  String    ville){
this.nom=  nom;  this.prenom=  prenom;    this.age=  age;    
this.ville=  ville;}

public  String  afficher(){
return"ʺ  le  nom  est  :  "ʺ+nom+"ʺ    "ʺ+  prenom+  "ʺ  L’age  :    "ʺ+  age+  "ʺans  "ʺ+      
"ʺ  habite  à    "ʺ+ville);  }  }

public    class  Employe  extends  Personne{    
       private  String    societe;
       private  double    salaire;
…..}
 Pour  initialiser  le  nom,  le  prenom,  l’age  et  la  ville    

d’un  employé  

public    Employe(String    n,  String    p,  int  a,  String    v,  String  s,  double    sa){

super(n,p,a,v)
this.societe=s;
public  Personne(String    n,  String    p,  int  a,  String    v)
this.salaire=sa; {this.nom=  n;  
} this.prenom=  p;  
        this.age=  a;  
this.ville=  v;}

Remarque  :  super  est  le  mot-­‐‑clé  pour  désigner  l'ʹappel  au  

constructeur  de  la  super  classe  (ou  classe  mère).

Redéfinir  une  méthode  héritée:  le  polymorphisme

public  String  afficher()  { Appel  de  la  méthode  afficher()  

de  la  classe  Mère  :Personne
   
 return    super.afficher()+  "ʺ    société  :  "ʺ  +  this.societe+  "ʺ  le  salaire  :  
"ʺ+this.salaire);  }

—  Dans  la  classe  d’appel  :

Employe  p=  new  Employe(  "ʺn1"ʺ,    "ʺp1  "ʺ40,  "ʺrabat"ʺ,  "ʺTelec"ʺ,10000);
                 label1.setText(p.afficher());            }

—  Le  Résultat  est  :

le  nom  est  :  n1    p1    L’age  :      40  ans      habite  à      rabat  
société  :  Telec    le  salaire  :  10000    
 HÉRITAGE
Exemple 2 :
Class Point
{protected int x;
protected int y;

Point (int x, int y)

{this.x = x;
this.y = y; }

Point () {
this(-1, -1); }
}
 HÉRITAGE
class Point3D extends Point
{ int z;

Point3D(int x, int y, int z)

{ super(x,y);
this.z = z; }

Point3D() {
this(-1, -1, -1); }
}
Soit la classe Etudiant qui hérite de classe Personne et qui a comme
attributs.
numeroInscription int, nbreAbsences int
•  Définir la classe Etudiant.
•  Ajouter un constructeur qui initialise tous les attributs de classe
Etudiant.
•  Ajouter une méthode afficher() qui retourne l’état d’un étudiant.
•  Ajouter une méthode absence() qui incrémente le nombre des
absences d’un étudiant.
Soit la classe Professeur qui hérite de classe Personne et qui a comme
attributs :
matricule: int, nbHeureSup: int, tauxHoraire : double, salaireFixe:double
•  Définir la classe Professeur.
•  Ajouter un constructeur qui initialise tous les attributs de la classe
Professeur.
•  ajouter une méthode afficher() qui retourne l’état d’un professeur.
•  Ajouter une méthode calculerSalaire() qui retourne le salaire d’un
professeur.
 Synthèse
•  Une classe hérite d'une autre classe par le biais du mot clé
extends.
•  Une classe ne peut hériter que d'une seule et unique classe !
•  La classe fille hérite de toutes les propriétés et méthodes public
et protected de la classe mère.
•  On peut redéfinir une méthode héritée, c'est-à-dire qu'on peut
changer tout son code.
•  On peut utiliser le comportement d'une classe mère par le biais
du mot clé super.
•  Si une méthode d'une classe mère n'est pas redéfinie ou
« polymorphée », à l'appel de cette méthode par le biais d'un
objet enfant, c'est la méthode de la classe mère qui sera utilisée.
•  Vous ne pouvez pas hériter d'une classe déclarée final.
•  Une méthode déclarée final est non redéfinissable.
 Les  classes  abstraites  

•  une classe abstraite est comme une classe normale.

Ceci dit, elle a tout de même une particularité :
vous ne pouvez pas l'instancier !

public  class  Test{  

public  static  void  main(String[]  args){
 A  obj  =  new    A();          //Erreur  de  compilation  !  !  
}
 }
 Périmètre  ()
Surface  ()
Afficher  ()

Périmètre  () Périmètre  () Périmètre  ()

Périmètre  () Surface  ()
Surface  () Surface  ()
Surface  () Afficher  ()
Afficher  () Afficher  ()
Afficher  ()
 La  classe  Figure  doit  être    abstraite  

•  Une classe considérée comme abstraite. Elle doit être

déclarée avec le mot clé abstract.
abstract  class  Figure{
…..}
•  Une telle classe peut avoir le même contenu qu'une
classe normale (attributs et méthodes). En plus, la classe
abstraite permet de définir des méthodes abstraites. Ces
méthodes ont une particularité ; elle n'ont pas de corps !
abstract  class  Figure{
abstract  double  perimetre();    //  une  méthode  abstraite  
}
•  Une méthode abstraite ne peut exister que dans une
classe abstraite
public  abstract  class  figure  {
protected  String  centre;
protected  String  couleur;

figure(String  centre,  String  couleur){
       this.centre=centre;        this.couleur=couleur;}
/  la  méthode  abstraite
abstract  double  surface();

//  la  méthode  abstraite
abstract  double  perimetre();

String  afficher(){  return  "ʺcentre  :  "ʺ+  centre  +  "ʺcouleur  :  "ʺ+  couleur;}

public  class  Cercle  extends  figure{
                                           private  double  rayon;
                                           private  final  double  pi  =3.14;

Cercle(String  centre,String  couleur,double  rayon){
               super(centre,couleur);
               this.rayon=rayon;    }

//  Implémentation  de  la  méthode  abstraite  
   double  perimetre(){    return    2*pi*rayon;      }
//  Implémentation  de  la  méthode  abstraite  
   double  surface(){    return    rayon*rayon*pi;      }

//  le  polymorphisme  de  la  méthode  afficher();
       void  afficher()  {        super.afficher()  +    "ʺson  rayon  "ʺ+  rayon+  "ʺsa  
surface  est  :  "ʺ+this.surface()+  "ʺson  perimetre  est  :  "ʺ+  
this.perimetre()  ;  }
}
public  class  Rectangle  extends  figure{
                                           private  double  Largeur;
                                           private  double  Longueur;
                               
           

Rectangle(String  c,  String  co,  double    longueur,  double  largeur){

               super(c,co);
                 this.largeur=largeur;
                 this.longueur=longueur;  }

//  Implémentation  de  la  méthode  abstraite  

   double  perimetre(){    return    2*(largeur+longueur);      }

//  Implémentation  de  la  méthode  abstraite  
   double  surface(){    return  largeur*longueur;}

//  le  polymorphisme  de  la  méthode  afficher();
void  String  afficher()  {        super.afficher()        +    "ʺsa  largeur  :  "ʺ    
+largeur+      "ʺsa  longueur  :    "ʺ+  longueur+  "ʺsa  surface  
est  :  "ʺ+this.surface()+  "ʺson  perimetre  est  :  "ʺ+  this.perimetre()  ;  }}}
public  class  Carré  extends  figure{
                                           private  double  coté;
                                                                                       
Carré  (String  c,  String  co,  double  coté){
               super(c,co);
                 this.  coté=coté;}

//  Implémentation  de  la  méthode  abstraite  
   double  perimetre(){    return  coté*4;      }

//  Implémentation  de  la  méthode  abstraite  
   double  surface(){    return  coté*coté;}

//  le  polymorphisme  de  la  méthode  afficher();
void  String  afficher()  {        super.afficher()        +      "ʺson  coté"ʺ    +coté+    "ʺsa  
surface  est  :  "ʺ+this.surface()+  "ʺson  perimetre  est  :  "ʺ+  
this.perimetre()  ;  }  }
public  class  Appel  {

public  static  void  main(String[]  args)  {
               
             figure    f=  new  Cercle("ʺC"ʺ,  "ʺrouge"ʺ,12);
             figure    r=new  Rectangle("ʺO"ʺ,  "ʺbleu"ʺ,12,14);

             Label1.setText(  f.perimetre());
             Label1.setText  (f.position());
             Label1.setText  (f.surface());
             Label1.setText  (f.afficher());

             Label1.setText  (  r.perimetre());
             Label1.setText  (r.position());        
             Label1.setText  (r.surface());
             Label1.setText  (r.afficher());  }
Exercice Personne

Nom
Prénom
Societe

Num  


getSalaire()
getInfo()

Ouvrier
Patron
Cadre

dateEntree   Ca
SMIG Indice  ; pourcentage      
getSalaire()   getSalaire()   getSalaire()  
getInfo() getInfo() getInfo()

Créer la classe Ouvrier, la classe Cadre et la classe Patron qui
héritent de la classe Personne. et prévoir les constructeurs (à 3
et à 0 arguments) de chacune des 3 classes,
Le patron a un salaire qui est égal à x% du chiffre d'affaire :
salaire = cA*pourcentage/100
Le cadre a un salaire qui dépend de son indice :
E1 : salaire annuel brut 120.000,00 Dh,
E2 : salaire annuel brut 130.000,00 Dh,
E3 : salaire annuel brut 140.000,00 Dh,
E4 : salaire annuel brut 150.000,00 Dh,
L’ouvrier a un salaire égale = SMIG + (age-18)*100 +
( dateCourante - dateEntree)*150. De plus, le salaire ne doit
pas dépasser SMIG*2.
Ecrire la méthode float getSalaire() qui permet de calculer le
salaire pour chacune des classes.
Ecrire la méthode String getInfo() qui renvoie le nom,
le prénom, la société , le salaire et le poste occupé
(On pourra utiliser la méthode getInfo() de classe
mère et rajouter l'information du poste occupé).
Le programme principal devra créer 1 patron et 2
cadres aux indice E1 et E3 et 5 ouvriers. Tester les
différentes fonctions.
Afficher les informations concernant les différents
employés.
 Les  différences  entre  les  interfaces  
et  les  classes  abstraites  :    
•  super classe, alors qu’une
une classe abstraite n’a qu’une
classe interface peut dériver de plusieurs autres interfaces.
•  Des classes non liées hiérarchiquement peuvent implémenter
la même interface
•  Une classe peut implémenter plusieurs interfaces (permettant
un héritage multiple, en les séparant par des virgules après le
mot implements).
•  Toutes les méthodes d'une interface sont implicitement
abstraites.
•  Une interface n'a pas de constructeurs
•  Une interface ne peut avoir de champs sauf si ceux-ci sont
statiques.
 Définition  de  l'ʹinterface  

package cours;

public interface Vehicule {

void rouler();
void freiner();
}
package cours;
public class Velo implements Vehicule {
private String marque;
private int rayonRoue;

public Velo(String marque, int rayonRoue)

{ this.marque = marque;
this.rayonRoue = rayonRoue;}

public void rouler() {…..}

public void freiner() {……}
}
package cours;
public class Auto implements Vehicule {
private String marque;
private int poids;

public Auto(String marque, int poids)

{ this.marque = marque;
this.poids = poids;}
public void rouler() {……}

public void freiner() { ……}

}