Programmation Orientée Objets et Evénementielle

Ce document propose une série d'exercices sur la programmation orientée objets en Java, portant sur les notions de classes, héritage, polymorphisme, classes abstraites et collections. Il s'agit d'un contrôle continu ou d'un devoir surveillé visant à tester la compréhension des concepts fondamentaux de la programmation orientée objets, la capacité à analyser et corriger un code existant, ainsi qu'à concevoir et implémenter des solutions en Java.

Exercice 1 : Analyse d'un programme Java

Il s'agit d'analyser un programme Java comportant une hiérarchie de classes Livre, BD, Album, et de comprendre son fonctionnement, notamment l'héritage, les constructeurs, les méthodes et l'encapsulation.

1) Que va afficher le programme lors de son exécution ?

Le programme crée plusieurs objets :

• Deux BD (bandes dessinées) b1 et b2 avec des titres, auteurs, prix, nombre de pages et un booléen indiquant si elles sont en couleur.
• Deux livres l1 et l2 avec titres, auteurs, prix et nombre de pages.
• Un album a1 avec titre, auteur, nombre de pages et prix.

Les appels successifs sont :

• b1.Acheter("moi") : assigne "moi" comme propriétaire de b1.
• b1.Afficher() : affiche les informations de b1.
• b2.Afficher() : affiche les informations de b2.
• l1.Afficher() : affiche les informations de l1.
• l1.Acheter("moi") : assigne "moi" comme propriétaire de l1.
• l1.Afficher() : affiche les informations de l1 mises à jour.
• l1.prix = 0.0 : modifie le prix de l1.
• l2.Acheter("lui") : assigne "lui" comme propriétaire de l2.
• l2.Afficher() : affiche les informations de l2.
• a1.Afficher() : affiche les informations de l'album a1.
• a1.Colorie(23) : tente de colorier la page 23 de l'album.
• a1.Acheter("moi") : assigne "moi" comme propriétaire de a1.
• a1.Colorie(23) : tente de recolorier la page 23.

Les affichages pour chaque objet sont :

• BD b1 : affiche titre, auteur, prix, nombre de pages, et indique si elle est en couleur. Le propriétaire est "moi".
• BD b2 : même affichage, propriétaire vide.
• Livre l1 : affiche titre, auteur, prix (modifié à 0.0 après achat), nombre de pages, propriétaire "moi".
• Livre l2 : affiche titre, auteur, prix, nombre de pages, propriétaire "lui".
• Album a1 : affiche titre, auteur, prix, nombre de pages, propriétaire vide initialement.
• Lors du premier appel a1.Colorie(23), la page 23 n'est pas encore coloriée, le propriétaire est vide donc l'album est neuf, la page 23 est coloriée et un message indique que la page est coloriée.
• Après a1.Acheter("moi"), le propriétaire devient "moi".
• Lors du second appel a1.Colorie(23), la page 23 est déjà coloriée, donc un message indique que la page est déjà coloriée.

En résumé, le programme affiche les informations des livres et bandes dessinées avec leurs attributs, indique les propriétaires, et gère la coloration des pages de l'album en fonction de leur état et du propriétaire.

2) Comment Java interprète-t-il l'attribut prix défini sans modificateur d'accès dans Livre ? Comment est-il testé dans le programme ?

L'attribut prix est défini sans modificateur d'accès (ni public, ni private, ni protected), ce qui signifie qu'il a un accès par défaut (package-private). Cela veut dire qu'il est accessible uniquement aux classes du même paquet.

Dans le programme, on voit que l'attribut prix est modifié directement dans le code principal par l1.prix = 0.0;, ce qui est possible car la classe Test est dans le même paquet que Livre.

Conclusion : l'attribut prix est accessible en lecture et écriture dans les classes du même paquet, ce qui est confirmé par la modification directe dans le programme.

3) Comment teste-t-on si un livre est neuf dans ce programme ?

La méthode Est_neuf() teste si un livre est neuf en vérifiant si l'attribut proprietaire est vide :

if (proprietaire == "") return true;
else return false;

Autrement dit, un livre est considéré neuf s'il n'a pas encore de propriétaire.

Donc, le critère pour un livre neuf est que son propriétaire soit la chaîne vide.

4) Décrire la hiérarchie des classes et expliquer l'appel des constructeurs

La hiérarchie est la suivante :

• Livre est la superclasse de base, avec les attributs titre, auteur, propriétaire, nombre de pages, prix.
• BD (bande dessinée) étend Livre et ajoute un attribut encouleur (booléen).
• Album étend Livre et ajoute un tableau booléen page_coloriee[] pour suivre les pages coloriées.

Concernant les constructeurs :

• Le constructeur de Livre initialise les attributs titre, auteur, prix, nombre de pages, et met propriétaire à vide.
• Le constructeur de BD appelle super(t,a,p,nb) pour initialiser les attributs hérités, puis initialise encouleur.
• Le constructeur de Album appelle aussi super(t,a,p,n) et initialise le tableau page_coloriee à false pour toutes les pages.

En résumé, chaque sous-classe appelle explicitement le constructeur de sa superclasse pour initialiser les attributs hérités avant d'initialiser ses propres attributs.

5) Comment le programme gère-t-il la coloration d'une page d'un album ?

La classe Album possède un tableau booléen page_coloriee[] qui indique pour chaque page si elle est coloriée ou non.

La méthode Colorie(int num_page) fonctionne ainsi :

• Si la page num_page n'est pas encore coloriée (page_coloriee[num_page] == false) et que l'album est neuf (Est_neuf() retourne true), alors la page est coloriée (valeur mise à true) et un message indique que la page vient d'être coloriée.
• Si la page est déjà coloriée, un message indique que la page a déjà été coloriée.
• Si l'album n'est pas neuf (propriétaire non vide), un message indique qu'il n'est pas possible de colorier car l'album a déjà un propriétaire.

Le programme empêche donc de colorier une page si l'album a déjà un propriétaire ou si la page est déjà coloriée.

6) Identifier et corriger les erreurs de frappe dans le code

Plusieurs erreurs sont présentes :

• class BD extend Livre doit être class BD extends Livre.
• Les modificateurs d'accès sont mal placés : protected string titre, auteur, proprietaire; doit être protected String titre, auteur, proprietaire; (Java est sensible à la casse).
• Dans le constructeur de BD, la déclaration et l'initialisation des paramètres sont mal ordonnées et incomplètes.
• La boucle dans Album pour initialiser page_coloriee va jusqu'à 100, or le nombre de pages est n ; il faut remplacer i < 100 par i < n.
• La méthode Colorie contient des erreurs de syntaxe et d'affichage (parenthèses mal placées, messages incomplets).
• Les noms des méthodes doivent respecter la casse : acheter doit être Acheter pour correspondre à la déclaration.

Ces corrections sont nécessaires pour que le code compile et fonctionne correctement sous Eclipse.

Exercice 2 : Héritage de classe et constructeurs

Il s'agit de concevoir et d'implémenter une hiérarchie de classes pour un site de vente de livres pour enfants, incluant bandes dessinées et albums à colorier, avec gestion des fonctionnalités supplémentaires.

1) Proposer une solution pour représenter les livres, BD et albums à colorier

On définit :

• Une classe Livre avec les attributs titre, auteur, prix, nombre de pages.
• Une classe BD qui étend Livre et ajoute un booléen encouleur.
• Une classe Album qui étend Livre et permet de colorier des pages via un tableau booléen.

Chaque classe possède un constructeur initialisant ses attributs et des méthodes adaptées (affichage, coloration).

Cette solution est conforme à la hiérarchie et aux fonctionnalités décrites.

2) Ajouter la possibilité de revendre un livre et d'échanger deux BD de prix équivalent

Pour revendre un livre, on peut ajouter une méthode Vendre() qui remet le propriétaire à vide.

Pour échanger deux BD, on peut créer une méthode statique ou d'instance qui échange les propriétaires si les prix sont égaux :

if (bd1.prix == bd2.prix) {
  String temp = bd1.proprietaire;
  bd1.proprietaire = bd2.proprietaire;
  bd2.proprietaire = temp;
}

Cette modification permet de gérer la revente et l'échange selon les critères donnés.

3) Étendre la hiérarchie pour intégrer les films (DVD)

On crée une nouvelle classe Film qui étend une superclasse commune (par exemple OeuvreCulturelle), ou directement Livre si on considère que les films partagent les attributs titre, auteur et prix.

La classe Film ajoute un attribut durée (entier ou réel).

Le constructeur de Film initialise titre, auteur, prix et durée.

Cette extension permet d'intégrer les films dans la hiérarchie des œuvres culturelles.

Exercice 3 : Héritage de classe et polymorphisme

Il s'agit de modéliser la programmation journalière d'émissions télévisuelles de différents types, en utilisant héritage, classes abstraites et polymorphisme.

1) Proposer une hiérarchie de classes pour les émissions

On peut définir :

• Une classe abstraite Emission avec attributs communs : nom, heure de début, heure de fin.
• Une classe Divertissement qui étend Emission, avec attribut animateur, durée fixe de 2 heures.
• Une classe Fiction qui étend Emission, avec attributs nom du film, année, réalisateur, booléen rediffusion.
• Une classe Reportage qui étend Emission, avec attribut thème (information, animalier, culturel) et durée.

Le thème du reportage peut être codé par un enum ou une constante pour limiter les valeurs possibles.

Cette hiérarchie permet de représenter toutes les émissions possibles avec leurs caractéristiques.

3) Programmer la gestion des heures de diffusion selon les règles

On crée une méthode abstraite dans Emission pour programmer l'heure de début et calculer l'heure de fin en fonction des règles :

• Divertissement : durée 2h, programmation possible uniquement entre 18h et 23h.
• Fiction : non rediffusion programmée uniquement à 21h, rediffusion possible à tout moment.
• Reportage : programmation uniquement aux heures creuses (14h, 18h, 0h-6h) et durée ≤ 1h.

La méthode retourne un booléen indiquant si la programmation est possible.

Cette solution utilise le polymorphisme pour adapter la programmation selon le type d'émission.

4) Définir un programme télé comme un tableau d'émissions et implémenter les algorithmes

On crée un tableau d'objets Emission[] contenant des instances hétérogènes.

Les algorithmes :

• a) Afficher la liste des émissions programmées : parcourir le tableau et appeler une méthode d'affichage polymorphe.
• b) Tester la superposition : vérifier que les plages horaires des émissions ne se chevauchent pas.
• c) Afficher heure par heure les émissions : parcourir les heures de la journée et afficher l'émission programmée ou "vide".

Ces algorithmes permettent de gérer et vérifier la programmation télévisuelle.

Exercice 4 : Classes abstraites, héritage, collections ArrayList

Il s'agit d'implémenter une hiérarchie de formes géométriques : Point, Cercle, Cylindre, avec une classe abstraite Forme.

1) Implémenter la classe abstraite Forme

La classe Forme est abstraite et définit trois méthodes abstraites :

• aire() : calcul de l'aire de la forme.
• volume() : calcul du volume de la forme.
• afficherNom() : affichage du nom de la forme ("point", "cercle", "cylindre").

Cette classe sert de base pour les autres formes.

2) Classe Point

La classe Point étend Forme et possède deux coordonnées réelles x et y.

Elle propose des getters et setters pour ces coordonnées et une méthode toString() affichant les coordonnées sous la forme [x, y].

Les méthodes aire() et volume() retournent 0 car un point n'a pas d'aire ni de volume.

3) Classe Cercle

La classe Cercle étend Point et ajoute un attribut réel rayon.

Deux constructeurs :

• Sans paramètre : centre (0,0), rayon 0.
• Avec paramètres : coordonnées du centre et rayon.

La méthode toString() affiche centre et rayon.

La méthode aire() calcule l'aire par la formule :

3.14158 * rayon * rayon

La méthode volume() retourne 0.

4) Classe Cylindre

La classe Cylindre étend Cercle et ajoute un attribut réel hauteur.

Elle propose des getters et setters pour la hauteur.

Les méthodes :

• aire() calcule :

2 * aire du cercle + 2 * 3.14159 * rayon * hauteur

• volume() calcule :

aire du cercle * hauteur

La méthode toString() affiche centre, rayon et hauteur.

5) Tester l'implémentation avec FormeTest

On crée :

• Un point (5,5)
• Un cercle de centre (10,15) et rayon 8.5
• Un cylindre de centre (30,30), rayon 12.5 et hauteur 20

On affiche les coordonnées, aires, volumes et noms des formes.

Les résultats attendus sont :

[5.0, 5.0]
Aire de Point = 0.0 et volume = 0.0
Centre = [10.0, 15.0], Rayon = 8.5
Aire de Cercle = 226.9798775 et volume = 0.0
Centre = [30.0, 30.0], Rayon = 12.5, hauteur = 20.0
Aire de Cylindre = 2552.541875 et volume = 9817.46875

Ce test valide la bonne implémentation des classes et méthodes.

Exercice 5 : Collections ArrayList et gestion de véhicules

Un collectionneur possède différents types de véhicules (autos, motos, camions) avec marque, modèle et couleur. Il souhaite gérer sa collection avec plusieurs fonctionnalités.

1) Proposer une solution orientée objet pour représenter les véhicules

On crée une classe de base Vehicule avec attributs marque, modèle, couleur.

Les classes Auto, Moto, Camion étendent Vehicule.

Le type du véhicule est géré par l'héritage.

Cette structure permet de représenter tous les véhicules.

2) Implémenter la solution sous Eclipse et tester les classes

On crée des instances de chaque type de véhicule avec leurs attributs et on teste les constructeurs et méthodes d'affichage.

3) Gérer la collection avec ArrayList

On utilise une ArrayList<Vehicule> pour stocker les véhicules, car le nombre de véhicules n'est pas connu à l'avance.

L'affichage se fait avec ou sans itérateur.

4) Créer une classe héritant d'ArrayList pour répondre aux besoins spécifiques

Cette classe ajoute des méthodes pour :

• Afficher les véhicules d'une couleur donnée.
• Rechercher un véhicule par marque et modèle.
• Vendre un véhicule (le retirer de la liste).

5) Interface graphique

Une interface graphique est créée avec une liste de boutons représentant chaque véhicule. Cliquer sur un bouton affiche les informations détaillées du véhicule sélectionné.

Cette solution complète permet de gérer efficacement la collection de véhicules.

Méthodologie récompensée par ce sujet

Ce sujet valorise :

• La compréhension précise des concepts d'héritage, encapsulation, polymorphisme et classes abstraites.
• La capacité à analyser un code existant, identifier ses erreurs et proposer des corrections justifiées.
• La rigueur dans l'implémentation des constructeurs et méthodes, notamment l'appel aux super-constructeurs.
• L'usage correct des modificateurs d'accès et la gestion des attributs selon les règles Java.
• La conception d'une hiérarchie de classes cohérente et adaptée aux besoins fonctionnels.
• L'application du polymorphisme pour gérer des comportements spécifiques selon le type d'objet.
• L'utilisation des collections (ArrayList) et des itérateurs pour gérer des ensembles dynamiques d'objets.
• La clarté dans la présentation des solutions, avec des étapes explicites et des justifications.

Les erreurs pénalisées sont notamment :

• Les fautes de syntaxe et de casse en Java.
• Le non-respect des conventions d'appel des constructeurs.
• L'oubli de l'encapsulation ou l'accès incorrect aux attributs.
• Une mauvaise gestion des types et des hiérarchies.
• Le manque d'explications ou de raisonnement dans les réponses.

En résumé, ce sujet récompense une approche méthodique, rigoureuse et complète de la programmation orientée objets en Java.