Les éléments abstraits

1. La déclaration de méthodes abstraites

Au sein d’une classe abstraite, il est possible de créer des méthodes abstraites. Une méthode abstraite est une méthode qui ne possède pas de corps. Il n’y a que sa signature qui est indiquée. Il n’y a pas de déclarations de variables ou de constantes, ni d’instructions, ni même les mots-clés Début et Fin.

Syntaxe pour une procédure :

Procédure abstraite nomDeLaProcedure(listeDesParamètres) 

Syntaxe pour une fonction :

Fonction abstraite nomDeLaFonction(listeDesOaramètres) Retourne 
typeDeRetour 

Le fait de déclarer une méthode abstraite au sein d’une classe abstraite va obliger les classes concrètes qui en héritent à avoir une définition concrète de cette méthode, c’est-à-dire avec un corps contenant des instructions. L’intérêt des méthodes abstraites est qu’elles permettent de s’assurer de la présence de certaines méthodes dans les classes concrètes qui en héritent.

Étant donné qu’il n’est possible de créer des instances que de classes concrètes et que celles-ci ont forcément donné un corps pour toutes les méthodes abstraites héritées, l’appel à une méthode sur une instance exécute donc bien une méthode concrète.

Dans la classe Joueur, deux méthodes abstraites peuvent être ajoutées afin d’obliger toutes les classes concrètes à avoir ces méthodes et à leur donner un corps.

Exemple :

Classe abstraite Joueur  
  
Attribut nom : texte  
Attribut champDeTir : Grille  
Attribut bateaux : Bateau[5]  
Attribut nbBateaux : entier  
Attribut nbBateauxCoules : entier  
Attribut adversaire : Joueur  
  
Méthodes  
  
Constructeur()  
Début  
 champDeTir <- nouveau Grille()  
 nbBateaux <- 0  
 nbBateauxCoules <- 0  
Fin  ...

1. La déclaration d’une interface

Une interface est un peu comme une classe abstraite, mais en version minimaliste. Une interface peut contenir des méthodes abstraites, mais ne peut plus avoir de méthodes d’instance concrètes, de constructeurs ou d’attributs. Une interface permet donc de définir un ensemble de méthodes à implémenter.

Cela établit ainsi un contrat que certaines classes peuvent s’engager à respecter.

Pour définir une interface, il faut utiliser la syntaxe suivante :

Interface NomDeLInterface  
# définition de constantes  
  
# définition de méthodes abstraites  
  
FInterface 

Par exemple, il est possible de définir une interface Jouable contenant deux méthodes abstraites jouer() et getNomDuJeu() :

Interface Jouable  
  
Procédure abstraite jouer()  
Fonction abstraite getNomDuJeu() Retourne texte  
  
FInterface 

En Java, pour définir une interface, tout comme pour une classe, il faut créer un fichier portant le même nom que l’interface dans un dossier respectant l’arborescence du nom du package. Voici la syntaxe à utiliser :

visibilité interface NomInterface { 
// définition de constantes 
 
// définition de méthodes abstraites 
 
} 

La visibilité d’une interface est soit publique, soit restreinte au package.

Dans une interface, des constantes peuvent être définies. Celles-ci sont nécessairement publiques. Comme aucun attribut n’est autorisé dans une interface, les mots-clés public static final sont implicites, ils peuvent donc être omis.

Pour les méthodes, il en est de même : elles sont nécessairement publiques et abstraites. Les mots-clés public abstract sont donc également implicites et facultatifs.

Voici, par exemple, l’interface Jouable codée en Java :

package fr.eni.jeux; 
 
public interface Jouable { 
        void jouer(); 
        String getNomDuJeu(); 
} 

2. L’implémentation d’une interface

Une classe implémente une interface lorsqu’elle s’engage...

1. La location de cycles

L’objectif est de créer un programme permettant à un loueur de cycles d’afficher les modèles proposés à la location et les tarifs pratiqués.

Des vélos, des gyropodes et des gyroroues sont proposés à la location. Pour chacun, il est nécessaire de connaître sa marque, son modèle ainsi que sa date d’achat. Les vélos sont équipés d’un système de changement de vitesse. Certains possèdent plus de vitesses que d’autres. Les gyropodes et les gyroroues ont une certaine autonomie en kilomètres. En raison de son guidon, le gyropode nécessite que son pilote ait une taille minimale.

1. La location de cycles

a. Les classes et leurs attributs

Les éléments communs à tous les types de cycles ont été regroupés au sein d’une classe abstraite Cycle. Les gyropodes et les gyroroues ont en commun l’autonomie de leur moteur. Une sous-catégorie de cycle a donc été créée : les cycles électriques, représentés par la classe abstraite CycleElectrique. Enfin, les éléments spécifiques à un type de cycle particulier sont positionnés dans la classe correspondante.

b. Les méthodes

La méthode abstraite getTarifLocationHeure() de la classe Cycle permet de s’assurer que toutes les classes concrètes héritant de celle-ci possèdent une implémentation concrète de cette méthode. Cette méthode est définie dans les classes Velo, Gyroroue et Gyropode. Elle n’est par contre pas définie dans la classe CycleElectrique, car celle-ci étant abstraite, elle n’a pas l’obligation de le faire.

Classe abstraite Cycle  
Attribut dateAchat : LocalDate  
Attribut marque : texte  
Attribut modele : texte  
Méthodes  
  
Constructeur(dateAchat : LocalDate, marque : texte, modele : texte)  
Début  
 instance.dateAchat <- dateAchat  
 instance.marque <- marque  
 instance.modele <- modele  
Fin  
  
Fonction age() Retourne entier  
Début  
 Retourner instance.dateAchat.getNbAnnesPassees()  
Fin  
  
Fonction abstraite getTarifLocationHeure() Retourne réel  
  
Fonction toString() Retourne texte  
Variable age : entier <- age()  
Début  
 Retourner instance.marque & " " & instance.modele & " (" & age &  
                                        "an" & age>1?"s":"" & ")"  
Fin  
  
FClasse 

Classe Velo HériteDe Cycle  
Attribut nbVitesse...