Héritage (informatique)

Pour les articles homonymes, voir Héritage.

L’héritage est un concept puissant de la programmation orientée objet, permettant entre autres la réutilisabilité (décomposition du système en composants) et l'adaptabilité des objets grâce au polymorphisme. Elle se nomme ainsi car le principe est en quelque sorte le même que celui d’un arbre généalogique. Ce principe est basé sur des classes dont les « filles » héritent des caractéristiques de leur(s) « mère(s) ».

Chaque classe possède des caractéristiques (attributs et méthodes) qui lui sont propres. Lorsqu'une classe fille hérite d'une classe mère, elle peut alors utiliser ses caractéristiques.

• Si la classe mère est abstraite (retardée) il y a de forte chance qu'elle présente des caractéristiques abstraites (retardées). Pour être effective (instanciable), la classe fille doit alors les définir, sinon elle sera elle même abstraite.
• Si la classe mère est effective (toutes les caractéristiques sont définies) alors la classe fille est également effective. Il est possible d'y ajouter des caractéristiques, d'utiliser les caractéristiques héritées (appartenant aux parents) et de redéfinir les méthodes héritées. Généralement cette redéfinition se fait par surcharge sémantique (on déclare de nouveau la méthode avec le même nom et la même signature).

Exemple basique de diagramme UML représentant une relation d'héritage

Pour qu'une classe fille puisse hériter des propriétés de la classe mère, il faut que les propriétés de la classe mère possèdent des attributs de visibilité compatibles. Il existe dans la plupart des langages trois niveaux de visibilité (dont la définition peut changer légèrement) :

• Public est la visibilité la plus large (accessible directement en dehors de la classe)
• Private est la plus restrictive (accessible uniquement depuis la classe courante)
• Protected est intermédiaire et est visible par la classe courante, toutes les classes filles, mais inaccessible en dehors des classes mère/filles.

Certains langages permettent à une classe d’hériter des propriétés de plusieurs classes mères. On parle dans ce cas d'héritage multiple. Ce cas, plus puissant, est aussi moins trivial, causant entre autres le problème du diamant.

Propriétés de la notion d'héritage

Il s'agit d'une relation :

• Transitivité : si B hérite de A et si C hérite de B alors C hérite de A ;
• Non réflexif : une classe ne peut hériter d’elle même ;
• Non symétrique : si A hérite de B, B n’hérite pas de A ;
• Sans cycle : Il n'est pas possible que B hérite de A, C hérite de B et que A hérite de C.

Exemples

PHP

/* Déclaration des classes */
 
class abstract Animal {
//attributs
   /**
    * @var string   Donnée membre
    */
   public $name;
 
//accesseurs
   /**
    * @return string   animal name
    */
   public function name() {
      return $this->name;
   }
 
//Constructeurs
   /**
    * @param string   animal name
    */
   public function __construct($name) {
      $this->name = $name
   }
 
//Modificateurs
   /**
    * @param string   animal name
    */
   public function setName($name) {
      $this->name = $name
   }
 
//Méthodes
   public abstract function crier();
}
 
class Chat extends Animal {
//definition de la methode abstraite crier
   public function crier(){
      $this->miauler();
   }
 
//méthodes propres à Chat
   public function miauler() {
      echo 'miaou';
   }
}
 
class Chien extends Animal {
//definition de la methode abstraite crier
   public function crier() {
      $this->aboyer();
   }
 
//méthodes propres à Chien
   public function aboyer() {
      echo 'wouf';
   }
}
 
/* Utilisation des classes*/
 
//Instanciation de la classe chien (toutou devient un objet de type chien)
$toutou = new Chien('Rex');
 
//On envoie un message au chien en utilisant une de ses méthodes (ici aboyer)
$toutou->aboyer(); // Méthode de la classe Chien
$toutou->setName('Isidor'); // Méthode héritée de la classe parente Animal

Java

/* Déclaration des classes */
 
public abstract Animal {
   /**
    * @var string   Donnée membre
    */
   public String name;
 
//accesseurs
   /**
    * @return string   animal name
    */
   public String name() {
      return name;
   }
 
//Constructeurs
   /**
    * @param string   animal name
    */
   public Animal(String name) {
      this.name = name
   }
 
//Modificateurs
   /**
    * @param string   animal name
    */
   public void setName(String name) {
      this.name = name
   }
 
//Méthodes
   public abstract void crier();
}
 
public class Chat extends Animal{ 
//Constructeur
   public Chat(String name) {
      super(name);
   }
 
//définition de la méthode abstraite crier
   public void crier() {
      miauler();
   }
 
//Méthode
   public miauler() {
      System.out.println("miaou");
   }
}
 
public class Chien extends Animal{
//Constructeur
   public Chien(String name) {
      super(name)
   }
 
//définition de la méthode abstraite crier
   public void crier() {
      aboyer();
   }
 
//Méthode
   public aboyer() {
      System.out.println("ouf");
   }
}
 
/* Utilisation des classes*/
 
//Instanciation de la classe chien (toutou devient un objet de type chien)
Chien toutou = new Chien("Rex");
 
//On envoie un message au chien en utilisant une de ses méthodes (ici aboyer)
toutou.aboyer();            //méthode aboyer de la classe chien
toutou.recevoirNom("Isidor");//Appel d'une méthode héritée de la classe mère

Eiffel

-- Déclaration des classes
 
defered class ANIMAL
create -- constructeur
   setName
 
feature -- accesseurs
   name: STRING
      -- Donnée membre
 
feature -- modifieurs
   setName(name: STRING)
       -- set the animal name
       do
          Current.name := name
       end
 
feature -- other method
   crier
      defered
      end
end -- class ANIMAL
 
 
class CHAT
inherit
   ANIMAL
      rename
         crier as miauler   end
      redefine
         miauler    end
 
create
   setName
 
feature
   miauler
      do
         print("miaou");
      end
end
 
 
class CHIEN
inherit
   ANIMAL
      rename
         crier as aboyer   end
      redefine
         aboyer    end
 
create
   setName
 
feature
   aboyer
      do
         print("ouf");
      end
end
 
-- Utilisation des classes
--
-- Instanciation de la classe chien (toutou devient un objet de type chien)
main
   local
      toutou : CHIEN
   do
      create toutou.setName("Rex")
      toutou.aboyer                 -- méthode aboyer de la classe chien
      toutou.setName("Isidor");
   end

Voir aussi

• Programmation orientée objet

• Portail de la programmation informatique