Notion d'héritage en "orienté-objet"

Sommaire du document

Hériter... dans la vie, et en programmation

Nous héritons tous à notre naissance d'une partie du patrimoine génétique de nos parents. Malgré celà, nous développons nos propres caractéristiques en plus de celles dont nous héritons. Le principe est identique en orienté objet.

Nous pouvons par exemple définir une classe Personne.
Tous les objets issus de la classe Personne possèdent un nom et un prénom. Ce sont certains de leurs attributs.
Nous allons fournir à tous les objets de la classe Personne une méthode identifie() qui nous retourne le prénom suivi du nom de la personne.

Nous allons à présent gérer les personnes qui sont inscrites dans une bibliothèque. Ces lecteurs sont avant tout des personnes, et présentent donc toutes les caractéristiques de la classe Personne.
Mais les lecteurs possèdent tous certaines qualités (des attributs) communes (la date d'inscription, les livres empruntés) que ne possèdent pas toutes les personnes.

Nous pouvons créer une classe Lecteur, qui hérite des propriétés et des méthodes de la classe Personne, mais qui implémente des méthodes qui ne s'appliquent par exemple qu'à des personnes inscrites dans la bibliothèque. Nous remarquons de suite le gain de temps et d'espace, car nous ne sommes plus obligés de définir les méthodes et attributs qui sont déjà définis dans la classe Personne. Nous ne devons plus définir que ce qui différe de la classe dont nous héritons.

Les classes peuvent donc se présenter comme une arborescence, la racine étant en haut.

Nous dirons de la classe Personne qu'il s'agit d'une super classe, et de la classe Lecteur, qu'il s'agit d'une sous classe.

Bien que le concept d'héritage soit commun aux différents langages orientés-objet, cette page reflète plus spécifiquement l'héritage en Java.

 

Remarques à propos de l'héritage

Héritage multiple

Dans certains langages tels que le C++, nous pouvons retrouver un objet qui hérite de plusieurs parents (héritage multiple), mais dans d'autres comme en Java nous ne retrouverons que des objets qui n'héritent que d'un parent maximum.
Mais plusieurs sous classes peuvent hériter d'une même super classe, il ne s'agit pas la d'héritage multiple puisque chaque sous classe n'hérite que d'une classe.

Héritage par défaut

Chaque classe en Java ne peut posséder qu'une super classe, mais elle peut avoir un nombre illimité de sous classes. Toute super classe ou sous classe que nous créons hérite automatiquement de la classe Object (la super super classe). Les attributs et les propriétés de la classe Object sont donc accessibles.

Généraliser - Spécialiser

Le plus souvent, lorsque nous effectuons un déplacement vers le haut (vers la super classe), nous généralisons. En effet, plus la classe est proche de la super classe, moins elle possède de méthodes et d'attributs spécifiques. Comme nous groupons les éléments communs dans une super-classe, nous pouvons parler de factorisation de ces éléments. Une généralisation nous permet une certaine abstraction car tout objet d'une sous-classe peut-être considéré comme un objet de sa classe parent[1].

Le corollaire de cette affirmation est que plus nous nous éloignons de la super classe (plus nous descendons dans la structure), plus nous remarquons une spécialisation des classes.

 

L'héritage en Java

La représentation utilisée ici est UML. Une page est consacrée aux diagrammes de classes.

Définition de la classe Personne

Personne
- nom : String
- prenom : String
+ Personne ( String nom , String prenom )
+ identifie ( ) : String
+ getNom ( ) : String
+ getPrenom ( ) : String
  1. public class Personne {
  2. private String nom;
  3. private String prenom;
  4. /**
  5. * constructeur
  6. * @param nom
  7. * @param prenom
  8. */
  9. public Personne(String nom, String prenom){
  10. this.nom = nom;
  11. this.prenom = prenom;
  12. }
  13. /**
  14. * @return donne le nom.
  15. */
  16. public String getNom() {
  17. return nom;
  18. }
  19. /**
  20. * @return donne le prenom.
  21. */
  22. public String getPrenom() {
  23. return prenom;
  24. }
  25. }

Définition de la classe Lecteur

Lecteur
- inscription : Date
- emprunts : [ ] Livre
+ Lecteur ( String nom, String prenom, Date inscription )
+ emprunte ( Livre livre ) : void
+ rapporte ( Livre livre ) : void
+ getEmprunts ( ) : [] Livre
  1. import java.util.ArrayList;
  2. import java.util.Date;
  3. public class Lecteur extends Personne {
  4. private Date inscription;
  5. private ArrayList emprunts;
  6. /**
  7. * Constructeur
  8. * @param nom
  9. * @param prenom
  10. * @param inscription
  11. */
  12. public Lecteur(String nom, String prenom, Date inscription) {
  13. super(nom, prenom);
  14. this.inscription = inscription;
  15. }
  16. /**
  17. *
  18. * @return donne la liste des livres empruntés en ce moment
  19. */
  20. public ArrayList getEmprunts() {
  21. return emprunts;
  22. }
  23. public Date getInscription() {
  24. return inscription;
  25. }
  26. /**
  27. * Ajoute le livre à ses livres empruntés en ce moment
  28. * @param livre
  29. */
  30. public void emprunte(Livre livre){
  31. emprunts.add(livre);
  32. }
  33. /**
  34. * Rapporte un livre à la bibliothèque
  35. * Enlève donc le livre de ses livres empruntés en ce moment
  36. * @param livre
  37. */
  38. public void rapporte(Livre livre){
  39. emprunts.remove(livre);
  40. }
  41. }

Que pouvons nous remarquer de particulier dans ce code ?

  1. public class Lecteur extends Personne

Nous avons utilisé le mot réservé extends qui signifie que la classe Lecteur est une  (ou classe dérivée) de Personne.

  1. public Lecteur(String nom, String prenom, Date inscription) {
  2. super(nom, prenom);
  3. this.inscription = inscription;
  4. }

Dans notre constructeur, nous recevons un nom et un prénom définissant la personne. Nous n'avons défini ces variables nulle-part dans le code de la classe Lecteur, ce sont donc des propriétés que l'objet de type Lecteur hérite de la classe Personne.

Pour cette raison, afin d'éviter toute confusion possible, nous utilisons le constructeur de la super classe (Personne) pour instancier ces valeurs.

  • Nous pouvons remarquer que l'appel au constructeur de la super classe se fait à l'aide du mot réservé super.
  • Si le constructeur de la sous-classe n'appelle pas explicitement le constructeur de la superclasse, c'est le constructeur par défaut de cette dernière qui est invoqué.
  • Dans notre constructeur de sous-classe, l'invocation du constructeur de la superclasse doit être la première instruction. Aucune instruction ne peut se placer dans un constructeur avant l'appel du super constructeur.

La date d'inscription est une des caractéristiques de notre Lecteur, nous pouvons directement affecter la valeur de la date d'inscription à la variable inscription au moment de l'appel au constructeur de Lecteur, car nous considérons qu'un lecteur n'existe qu'à partir du moment où il est inscrit dans la bibliothèque. Nous pouvons remarquer ici l'emploi du mot clé this qui désigne la classe elle-même.

 

Réseaux sociaux

Vous pouvez modifier vos préférences dans votre profil pour ne plus afficher les interactions avec les réseaux sociaux sur ces pages.

 

Nuage de mots clés

19 mots clés dont 0 définis manuellement (plus d'information...).

Avertissement

Cette page ne possède pas encore de mots clés manuels, ceci est donc un exemple automatique (les niveaux de pertinence sont fictifs, mais les liens sont valables). Pour tester le nuage avec une page qui contient des mots définis manuellement, vous pouvez cliquer ici.

Vous pouvez modifier vos préférences dans votre profil pour ne plus afficher le nuage de mots clés.

 

Notes

  1.  Abstraction et héritage : Une page spécifique est consacrée à l'héritage vu comme une abstraction, et à la substitution selon B. Liskov : https://www.gaudry.be/oriente-objet-principe-substitution.html.

  2.  Unified Modeling Language : correspond à « langage de modélisation unifié” en français

  3.  UML : “Unified Modeling Language” (en français, « langage de modélisation unifié »)

 

Expériences des broliens...


Mercredi 05 Juillet 2006, 16:49 : Confusion avec Date

dans ton dernier exemple, tu peux mettre

  1. public Lecteur(String nom, String prenom, java.util.Date
  2. inscription) {
  3. super(nom, prenom);
  4. this.inscription = inscription;
  5. }


pour éviter toute confusion entre l'objet Date de java.util et l'objet Date de SQL

- Akira Sato -


 

Astuce pour imprimer les couleurs des cellules de tableaux : http://www.gaudry.be/ast-rf-450.html
Aucun commentaire pour cette page

© Ce document issu de l′infobrol est enregistré sous le certificat Cyber PrInterDeposit Digital Numbertection. Enregistrement IDDN n° 5329-216
Document créé le 17/04/05 02:18, dernière modification le Mercredi 28 Juin 2017, 15:26
Source du document imprimé : http:///www.gaudry.be/oriente-objet-heritage.html
St.Gaudry©07.01.02
Outils (masquer)
||
Recherche (afficher)
Recherche :

Utilisateur (masquer)
Apparence (afficher)
Stats (afficher)
15838 documents
455 astuces.
550 niouzes.
3107 definitions.
447 membres.
8121 messages.

Document genere en :
0,38 seconde

Mises à jour :
Mises à jour du site
Citation (masquer)
On dit que le désir naît de la volonté, c'est le contraire, c'est du désir que naît la volonté. Le désir est fils de l'organisation.

Denis Diderot
 
l'infobrol
Nous sommes le Jeudi 29 Juin 2017, 04:09, toutes les heures sont au format GMT+1.00 Heure, heure d'été (+1)