Les relations entre les classes

1. La notion d’héritage

La troisième relation qu’une classe peut posséder vis-à-vis d’une autre est l’héritage. L’objectif de l’héritage est de définir une classe non pas à partir de zéro, mais à partir d’une autre classe. La classe servant de base est nommée classe parent et celle créée en se basant sur celle-ci classe enfant ou fille.

Grâce à l’héritage, la classe fille aura déjà tous les attributs et toutes les méthodes définies dans la classe parent. Ces éléments sont obtenus en héritage, un peu comme les enfants héritent génétiquement de leurs parents : un enfant a par exemple la même apparence que son père et les mêmes yeux que sa mère. La grande différence par rapport aux humains, c’est que les classes n’ont qu’un parent.

En plus de ces éléments hérités, il sera possible d’ajouter des attributs et des méthodes supplémentaires.

Un enfant peut avoir des éléments qui lui sont propres, par exemple une cicatrice sur le front.

Les classes peuvent donc être vues comme une hiérarchie où les catégories les plus générales seraient les classes au sommet de cette hiérarchie, et de ces classes hériteraient des sous-catégories plus spécifiques.

1. La définition

Syntaxe :

visibilité class NomDeLaClasseEnglobante {  
  ...  
   
  private [static] class NomDeLaClasseInterne {  
    ...  
  }  
} 

La classe interne est définie au même niveau qu’un attribut ou une méthode de la classe englobante. Si le mot-clé static est positionné, alors il s’agit d’une classe utilitaire interne qui ne pourra contenir que des méthodes de classe. Ce cas de figure est plutôt rare. Une classe interne est généralement créée pour que la classe englobante puisse créer une ou plusieurs instances, mais que ces instances ne soient utilisées qu’au sein de cette classe englobante.

Une classe interne est définie comme habituellement, à la différence près de son emplacement inhabituel au sein d’une classe et de sa visibilité private. Elle peut définir comme toute autre classe, ses attributs d’instance ou de classe, ses constantes, ses constructeurs et ses méthodes d’instance ou de classe.

Par exemple, il est possible de définir une classe Commande définissant en son sein une classe Article. Cette classe Article n’est alors connue et utilisée que par la classe Commande. Il ne doit donc avoir aucun constructeur ou méthode publique qui prend un paramètre de type Article ou qui retourne un type Article. En revanche, tout ceci est possible si le constructeur ou la méthode est privé.

Exemple :

import java.time.LocalDateTime;  ...

1. L’encapsulation des constructeurs

À l’instar des attributs qui sont protégés en application du principe d’encapsulation, l’accès aux constructeurs peut également être contrôlé. Pour mettre cela en place, il faut que la classe ne possède que des constructeurs privés, ou protégés si des classes en héritent. Si la classe ne possède aucun constructeur explicite, n’oubliez pas qu’un constructeur par défaut est fourni et que celui-ci est public. Dans ce cas, vous pouvez créer explicitement un constructeur avec une visibilité privée ou protégée ne prenant pas d’argument et n’ayant aucune instruction, ainsi le constructeur par défaut n’est pas ajouté.

Depuis l’extérieur de la classe, il n’est plus possible de faire appel à un constructeur de celle-ci. Le seul moyen pour créer une instance est donc de faire appel à une méthode de classe retournant une instance de celle-ci. Cette encapsulation permet de n’appeler le constructeur qu’une fois que toutes les règles métier ont été vérifiées. La création d’une instance est un processus coûteux, ainsi, le constructeur n’est appelé que si réellement une instance doit être créée (lorsqu’une règle métier est vérifiée au sein d’un constructeur public et n’est pas satisfaite, il est possible d’interrompre le traitement, mais "le mal est déjà fait !"). De plus, afin de produire un code efficace...

1. La bataille de dés

Prérequis : Exercice 1 du chapitre La programmation orientée objet

Deux joueurs s’affrontent dans une bataille de dés : chaque joueur possède un dé à six faces et dix jetons.

Créer une classe JoueurBataille ayant comme attributs d’instance le nombre de jetons, un dé (une instance de la classe De) et le nom du joueur. Ajouter au sein de cette classe les autres éléments nécessaires. Créer un algorithme principal utilisant cette classe.

Exemple d’exécution :

2. Les clients (version 2)

Prérequis : Exercice 2 du chapitre La programmation orientée objet

Les clients créés au chapitre précédent...

1. La bataille de dés

Classe JoueurBataille  
Attribut nbJetons : entier  
Attribut de : De  
Attribut nom : texte  
Méthodes  
  
Constructeur()  
Début  
 instance.nom <- saisir("nom du joueur ?")  
 instance.nbJetons <- 10  
 instance.de <- nouveau De()  
Fin  
  
Fonction tourDeJeu() Retourne entier  
Début  
 écrire(instance.nom & " a fait un " & instance.de.lancer())  
 Retourner instance.de.getFaceTiree()  
Fin  
  
Fonction perdUnJeton() Retourne booléen  
Début  
 instance.nbJetons <- instance.nbJetons - 1  
 Retourner instance.nbJetons = 0  
Fin  
  
Procédure gagneUnJeton()  
Début  
 instance.nbJetons <- instance.nbJetons + 1  
Fin  
  
Fonction getNom() Retourne texte  
Début  
 Retourner instance.nom  
Fin  
  
Fonction getNbJetons() Retourne entier  
Début  
 Retourner instance.nbJetons  
Fin  
  
FClasse 

 

Algo BatailleDeDes  
Variable j1 : JoueurBataille <- nouveau JoueurBataille()  
Variable j2 : JoueurBataille <- nouveau JoueurBataille()  
Variable fin : booléen  
Variable score1, score2 : entier  
Début  
 Répéter  
   score1 <- j1.tourDeJeu()  
   score2 <- j2.tourDeJeu()  
   Si score1 > score2 Alors  
     écrire(j1.getNom() & " remporte")  
     j1.gagneUnJeton()  
     fin <- j2.perdUnJeton()  
   Sinon  
     Si score1 < score2 Alors  
       écrire(j2.getNom() & " remporte")  
       j2.gagneUnJeton()  
       fin <- j1.perdUnJeton()  
     Sinon  
       écrire("égalité")  ...