INF1220 Héritage et polymorphisme

TRAVAIL NOTÉ 5

HÉRITAGE ET POLYMORPHISME.

Feuille d’identité

Nom                        Prénom                

Numéro d’étudiant                        Trimestre        Automne 2022        

                Code postal                

Téléphone        Domicile                Travail                

        Cellulaire                

Courriel                

Nom du professeur ou son délégué           

Réservé à l’usage du professeur ou son délégué

Date de réception                             Date de retour                     

Note                     

Date d’envoi                     [pic 1]

QUESTION #1

Veuillez expliquer en quelques phrases les résultats ou les erreurs suivantes lors de l’utilisation de ces classes :

public class Main {

   public static void main(String[] args) {

      Chat cat1 = new Chat();

      cat1.greeting();

      Chien dog1 = new Chien();

      dog1.greeting();

      GrosChien bigDog1 = new GrosChien();

      bigDog1.greeting();

C'est un exemple de 'overriding', où chaque sous-classe surcharge la méthode greeting() de la superclasse. Ex: cat1.greeting() va afficher Meow!.

      Animaux animal1 = new Chien();

      animal1.greeting();

      Animaux animal2 = new Chien();

      animal2.greeting();

      Animaux animal3 = new GrosChien();

      animal3.greeting();

Classe Animaux est une superclasse abstraite, donc elle ne peut pas être instanciée (ex: Animaux animal = new Animaux();). Ici, on crée un objet de la sous-classe et le référant comme un type abstrait. C'est un exemple 'upcasting'. L'objet va pouvoir utiliser seulement les méthodes communes de la superclasse et de la sous-classe.

Ex:         animal1.greeting() va afficher Woof! et ne voit que cette méthode qui est présente dans les                 deux classes. animal1 ne voit pas greeting(Chien another).

        animal3.greeting() va afficher Woow!

      Chien dog2 = (Chien)animal2;

      GrosChien bigDog2 = (GrosChien)animal3;

      Chien dog3 = (Chien)animal3;

      dog2.greeting(dog3);

      dog3.greeting(dog2);

      dog2.greeting(bigDog2);

      bigDog2.greeting(dog2);

      bigDog2.greeting(bigDog1);

      Chat cat2 = (Chat)animal2;

   }

}

Ici c'est  un exemple de 'downcasting' et 'sur definition'. L'objet abstrait va posséder toutes les propriétés de la sous-classe. Donc il peut utiliser la méthode greeting(Chien another).

Chat cat2 = (Chat) animal2 va produire une ClassCastException puisque animal2 est un objet (instance) de la classe Chien et Chat n'est pas une sous-classe de Chien (il n'y a aucun lien entre Chien et Chat) donc on ne peut pas faire de 'casting' entre 2 classes non reliées. On peut utiliser la fonction suivante pour vérifier si animal2 est une instance de Chat:

        System.out.println(animal2 instanceof Chat); retourne faux.

        System.out.println(animal2 instanceof Chien); retourne vrai. 

QUESTION #2

En tant que programmeur, vous recevez le code suivant. Vous devez appliquer l’héritage afin que Cercle et Carré héritent à la fois de Forme et Resizable. Vous pouvez bien entendu modifier le code reçu. Utilisez votre bon jugement. Votre solution doit comprendre au moins une classe abstraite. Vous devez expliquer vos choix de manière détaillée: un travail remis avec des explications insuffisantes pourra se voir attribué la note de zéro, sans droit de reprise.

On va devoir modifier le code comme suit:

1. Interface Resizable. (Même qu'on devrait changer le nom car cela porte la confusion mais pour la         fin de ce travail, on va le laisser tel que).

        On va mettre ici la méthode double getPerimeter(), donc toutes classes qui implémentent cette         interface vont devenir redéfinir cette méthode qui retourne le périmètre d'une forme         quelconque.

2. Abstract class Forme implements Resizable.

        La classe Forme restera une classe abstraite qui servira comme un gabarit pour les sous-        classes Cercle et Carre et elle implémente l'interface Resizable. On la donnera les champs, un         constructeur, les méthodes accesseurs (resize(double)) et méthode toString pour afficher le         résultat. (Remarque qu'on n'a pas besoin d'implémenter la méthode getPerimeter() ici car par         définition, une classe abstraite ne peut pas être instancier, donc les sous-classes vont devoir         le faire). Vue que les sous-classes utilisent même type de variable (double), on peut en faire         une variable double nommée 'donnee'.

        De cette façon, si jamais on voudrait ajouter d'autre forme qui prend 2 données (par         exemple un rectangle), on pourrait facilement ajouter une deuxième donnée et faire un autre

        constructeur prenant 2 doubles comme paramètres et ainsi de suite.

4. Les sous-classes Cercle et Carre vont 'extends' la classe abstraite Forme, donc elles sont forcées         à implémenter la méthode getPerimeter() à leur manière (calcul du périmètre d'une forme n'est         pas pareille). Par défaut, on doit créer un constructeur et on va utiliser les données de la         superclasse.

Le programme contient 4 classes + 1 Main:

        1. Interface:                Resizable

        2. Abstraite:                Forme

        3. Sous-classes        Cercle et Carre

        4. Main                Main

[pic 2]

/*

 * Classe interface offrant comme service une méthode getPerimeter()

 * pour calculer le périmètre. Toutes classes qui implémentent cette

 * interface doivent implémenter ce service à sa manière.

 * Public pour être visible par tout.

 */

public interface Resizable {        

        /*

         * Méthode pour calculer périmètre d'une forme.