Exam on Object-Oriented Programming (Java)

Ce sujet d'examen porte sur la programmation orientée objet en Java, appliquée à la gestion d’un restaurant administratif. Il évalue la compréhension des concepts de classes, héritage, encapsulation, et la capacité à écrire des méthodes respectant des contraintes métier spécifiques.

Question 1

Il s'agit d'analyser si les quatre instructions de création d'objets de la classe ItemRepas compilent ou non.

• I1 : ItemRepas i1 = new ItemRepas();
  Le constructeur sans paramètre existe dans la classe ItemRepas. Cette instruction compile et s'exécute sans erreur.
• I2 : ItemRepas i2 = new ItemRepas("crumble", Categorie.dessert, 0.77);
  Le constructeur avec signature (String, Categorie, double) est défini. Cette instruction compile et s'exécute sans erreur.
• I3 : ItemRepas i3 = new ItemRepas(0.74);
  Aucun constructeur avec un seul paramètre de type double n'existe. Cette instruction provoque une erreur de compilation.
• I4 : ItemRepas i4 = new ItemRepas(Categorie.dessert);
  Le constructeur avec un paramètre de type Categorie est défini. Cette instruction compile et s'exécute sans erreur.

Résumé : I1 : oui, I2 : oui, I3 : non, I4 : oui.

Question 2

Écrire la classe abstraite RepasServi avec :

• Une liste d’items de repas initialisée vide à la création.
• Un attribut date de type chaîne de caractères au format AAAAMMJJ.
• Un constructeur prenant la date en paramètre.

Solution :

public abstract class RepasServi {
  private ArrayList<ItemRepas> listeItem = new ArrayList<ItemRepas>();
  private String date; // AAAAMMJJ

  public RepasServi(String date) {
    this.date = date;
  }
  // accesseurs supposés existants
}

La classe est abstraite, la liste d’items est initialisée vide, et la date est mémorisée.

Question 3

Écrire la classe RepasInvite qui hérite de RepasServi, avec un attribut indiquant si l’invité est adulte ou enfant (booléen), et un constructeur prenant la date et ce booléen.

Solution :

public class RepasInvite extends RepasServi {
  private boolean adulte = true; // true = adulte, false = enfant

  public RepasInvite(String date, boolean adulte) {
    super(date);
    this.adulte = adulte;
  }
  // accesseurs supposés existants
}

La classe étend RepasServi, mémorise l’information adulte/enfant, et appelle le constructeur parent.

Question 4

Écrire la classe RepasPersonnel avec :

• Un attribut membre de type MembrePersonnel représentant le membre du personnel associé.
• Un attribut statique droitAdmission fixé à 2,59 euros (modifiable).
• La classe hérite de RepasServi.

Solution :

public class RepasPersonnel extends RepasServi {
  private MembrePersonnel membre;
  private static double droitAdmission = 2.59;

  // accesseurs et autres méthodes supposés
}

La classe étend RepasServi, contient un membre et un droit d’admission statique.

Question 5

Écrire la méthode subvention dans RepasPersonnel qui retourne un montant selon l’indice INM du membre :

• 2,49 € si INM ≤ 320
• 2,24 € si 321 ≤ INM ≤ 400
• 1,84 € si 401 ≤ INM ≤ 465
• 0,45 € si 466 ≤ INM ≤ 550
• 0 sinon

Solution :

public double subvention() {
  int inmMembre = this.getMembre().getINM();
  if (inmMembre <= 320) return 2.49;
  else if (inmMembre <= 400) return 2.24;
  else if (inmMembre <= 465) return 1.84;
  else if (inmMembre <= 550) return 0.45;
  else return 0;
}

La méthode teste les intervalles et retourne la subvention correspondante.

Question 6

(a) Ajouter dans la classe MembrePersonnel un attribut liste des repas pris par ce membre.

(b) Ajouter une méthode ajouteRepas qui ajoute un repas à ce membre, en mettant à jour les associations. Si le repas est déjà associé à un autre membre, il est retiré de ce dernier et affecté au membre courant, avec un message d’information.

Solution :

public class MembrePersonnel {
  // attributs existants
  private ArrayList<RepasPersonnel> listeRepas = new ArrayList<RepasPersonnel>();

  public void ajouteRepas(RepasPersonnel repas) {
    if (!this.listeRepas.contains(repas)) {
      if (repas.getMembre() != null) {
        if (repas.getMembre() != this) {
          System.out.println("repas deja servi a " + repas.getMembre().getNom());
          repas.getMembre().listeRepas.remove(repas);
        } else {
          System.out.println("repas deja associe a ce membre");
          return;
        }
      }
      this.listeRepas.add(repas);
      repas.setMembre(this);
    }
  }
  // autres méthodes et accesseurs supposés
}

L’attribut listeRepas est ajouté, la méthode gère les cas d’association multiple et met à jour les liens.

Question 7

Écrire les méthodes de calcul du prix des repas pour les trois classes :

• RepasServi : méthode abstraite prix().
• RepasInvite : prix fixe 8,5 € si adulte, 6 € si enfant.
• RepasPersonnel : somme des prix des items + droit d’admission - subvention.

Solution :

public abstract class RepasServi {
  public abstract double prix();
}

public class RepasInvite extends RepasServi {
  private static double prixAdulte = 8.5;
  private static double prixEnfant = 6;

  public double prix() {
    if (adulte) return RepasInvite.prixAdulte;
    return RepasInvite.prixEnfant;
  }
}

public class RepasPersonnel extends RepasServi {
  public double prix() {
    double sommeItem = 0;
    for (ItemRepas it : this.getListeItem())
      sommeItem += it.getPrix();
    return sommeItem + RepasPersonnel.getDroitAdmission() - this.subvention();
  }
}

Les méthodes calculent le prix selon les règles données, en utilisant les attributs et méthodes existants.

Question 8

Écrire la méthode permettant d’ajouter un item à un repas :

• Pour RepasInvite, on autorise au plus un item par catégorie (entrée, plat, accompagnement, dessert).
• Pour RepasPersonnel, aucune restriction.

Solution :

public abstract class RepasServi {
  public void ajoute(ItemRepas item) {
    if (!this.listeItem.contains(item))
      this.listeItem.add(item);
  }
}

public class RepasInvite extends RepasServi {
  public boolean contientCategorie(Categorie cat) {
    for (ItemRepas it : this.getListeItem())
      if (it.getCategorie().equals(cat))
        return true;
    return false;
  }

  public void ajoute(ItemRepas item) {
    if (!this.contientCategorie(item.getCategorie()))
      super.ajoute(item);
    else
      System.out.println("Probleme d’ajout");
  }
}

// Pas de redéfinition dans RepasPersonnel, la méthode de la superclasse est utilisée.

La méthode dans RepasInvite vérifie la présence d’un item de la même catégorie avant ajout, sinon affiche un message d’erreur.

Méthode

Ce sujet récompense la maîtrise des concepts fondamentaux de la programmation orientée objet : définition et utilisation de classes abstraites, héritage, gestion des attributs statiques et d’instance, et écriture de méthodes respectant des contraintes métier précises.

Il est important de suivre strictement les signatures des constructeurs et méthodes telles que définies dans l’énoncé, sans ajouter d’attributs non demandés sauf si explicitement autorisé. La bonne gestion des associations bidirectionnelles (comme entre MembrePersonnel et RepasPersonnel) est essentielle, notamment pour éviter les incohérences.

Les erreurs de compilation sont sanctionnées si les constructeurs ou méthodes invoqués n’existent pas. Les tests conditionnels doivent être précis et exhaustifs, notamment pour la méthode subvention. Enfin, la gestion des collections (listes) doit être rigoureuse, en évitant les doublons et en respectant les contraintes métier (exemple : un seul item par catégorie dans RepasInvite).

Les erreurs fréquentes à éviter sont :

• Oublier d’appeler le constructeur parent dans les classes filles.
• Ne pas gérer correctement les cas où un repas est déjà associé à un autre membre.
• Ne pas respecter les signatures exactes des constructeurs et méthodes.
• Ajouter des attributs ou méthodes non demandés sans justification.
• Ne pas vérifier les conditions métier avant d’ajouter un item dans un repas invité.

En résumé, ce sujet valorise une programmation claire, conforme aux spécifications, avec un raisonnement rigoureux sur les relations entre objets et leurs comportements.