Polymorphisme

Ce TP porte sur le polymorphisme en langage Java. Il propose deux exercices permettant de comprendre comment utiliser l'héritage et le polymorphisme pour manipuler des objets de différentes classes via une même interface. Le travail consiste à écrire les classes nécessaires au fonctionnement de programmes donnés, en se concentrant sur les méthodes essentielles. Ce TP nécessite un environnement Java pour compiler et exécuter les programmes.

Objectifs

• Comprendre et appliquer le concept de polymorphisme en Java.
• Écrire des classes abstraites et des classes dérivées.
• Utiliser la surcharge et la redéfinition de méthodes.
• Manipuler des tableaux d'objets polymorphes.
• Produire des sorties formatées à partir d'objets polymorphes.

Prérequis et installation

• Connaissance de base du langage Java (classes, héritage, méthodes).
• Environnement Java installé (JDK) avec un compilateur et un terminal ou IDE.
• Connaissance des notions de classes abstraites et méthodes abstraites.
• Pas de matériel spécifique requis, uniquement un ordinateur avec Java.

Exercice 1 : Polymorphisme avec des formes géométriques

Dans cet exercice, vous devez écrire les classes permettant de faire fonctionner le programme suivant :

public class TestFormes {
  public static void main(String[] argv) {
    Forme[] figures = new Forme[3];
    figures[0] = new Carre(2);    // Carré de 2 cm de côté
    figures[1] = new Cercle(3);   // Cercle de 3 cm de rayon
    figures[2] = new Carre(5.2);  // Carré de 5,2 cm de côté
    for(int i=0; i < figures.length; i++)
      System.out.println(figures[i] + " : surface = " + figures[i].getSurface() + " cm2");
  }
}

Ce programme affiche la description de chaque forme ainsi que sa surface. La surface d'un carré est calculée par côté * côté et celle d'un cercle par π * rayon * rayon.

Vous devez créer les classes Forme, Carre et Cercle avec les méthodes nécessaires.

Solution 1 : Classe Forme avec attribut surface

La classe Forme contient un attribut surface et une méthode getSurface() qui retourne cette surface. Les classes Carre et Cercle calculent la surface dans leur constructeur et appellent le constructeur parent.

package ex1;

public class Forme {
  protected double surface;

  public Forme(double surface) {
    this.surface = surface;
  }

  public double getSurface() {
    return surface;
  }
}

package ex1;

public class Carre extends Forme {
  private double cote;

  public Carre(double cote) {
    super(cote * cote);
    this.cote = cote;
  }

  public String toString() {
    return "Carré (coté " + this.cote + " cm)";
  }
}

package ex1;

public class Cercle extends Forme {
  private double rayon;

  public Cercle(double rayon) {
    super(Math.PI * Math.pow(rayon, 2));
    this.rayon = rayon;
  }

  public String toString() {
    return "Cercle (rayon " + this.rayon + " cm)";
  }
}

Solution 2 : Classe Forme abstraite avec méthode abstraite

La classe Forme est définie comme abstraite avec une méthode abstraite getSurface(). Les classes Carre et Cercle implémentent cette méthode pour calculer la surface à la demande.

public abstract class Forme {
  public abstract double getSurface();
}

public class Carre extends Forme {
  private double cote;

  public Carre(double cote) {
    this.cote = cote;
  }

  public double getSurface() {
    return cote * cote;
  }

  public String toString() {
    return "Carre ( coté " + this.cote + " cm ) :";
  }
}

public class Cercle extends Forme {
  private double rayon;

  public Cercle(double rayon) {
    this.rayon = rayon;
  }

  public double getSurface() {
    return Math.pow(rayon, 2) * Math.PI;
  }

  public String toString() {
    return "Cercle (rayon " + this.rayon + " cm ) :";
  }
}

Exercice 2 : Polymorphisme avec des métiers

Dans ce deuxième exercice, vous devez écrire les classes permettant de faire fonctionner le programme suivant :

public class TestMetiers {
  public static void main(String[] argv) {
    Personne[] personnes = new Personne[3];
    personnes[0] = new Menuisier("Paul");
    personnes[1] = new Plombier("Jean");
    personnes[2] = new Menuisier("Adrien");
    for(int i=0; i < personnes.length; i++)
      personnes[i].affiche();
  }
}

Ce programme affiche une phrase indiquant le nom et le métier de chaque personne. Vous devez créer les classes Personne (abstraite), Menuisier et Plombier avec la méthode affiche() adaptée.

Classes à créer

package ex2;

public abstract class Personne {
  protected String nom;

  public Personne(String nom) {
    this.nom = nom;
  }

  public abstract void affiche();
}

package ex2;

public class Menuisier extends Personne {
  public Menuisier(String nom) {
    super(nom);
  }

  public void affiche() {
    System.out.println("Je suis " + this.nom + " le Menuisier");
  }
}

package ex2;

public class Plombier extends Personne {
  public Plombier(String nom) {
    super(nom);
  }

  public void affiche() {
    System.out.println("Je suis " + this.nom + " le Plombier");
  }
}

Résultats attendus

Pour l'exercice 1, le programme doit afficher :

Carré ( coté 2.0 cm ) : surface = 4.0 cm2
Cercle ( rayon 3.0 cm ) : surface = 28.26 cm2
Carré ( coté 5.2 cm ) : surface = 27,04 cm2

Pour l'exercice 2, le programme doit afficher :

Je suis Paul le Menuisier
Je suis Jean le Plombier
Je suis Adrien le Menuisier

Pièges courants

• Oublier de déclarer la méthode getSurface() comme abstraite dans la classe Forme si vous choisissez la solution abstraite.
• Ne pas redéfinir la méthode toString() dans les classes dérivées, ce qui empêche d'obtenir la description correcte dans l'affichage.
• Confondre les noms des classes ou des méthodes (ex. écrire Carre au lieu de Carré ou inverse).
• Ne pas appeler le constructeur parent dans la solution 1, ce qui empêche d'initialiser correctement l'attribut surface.
• Dans l'exercice 2, oublier d'ajouter un espace entre "Je suis" et le nom dans la méthode affiche(), ce qui produit une phrase collée.
• Ne pas déclarer la classe Personne comme abstraite, alors qu'elle contient une méthode abstraite affiche().