Programmation Orientée Objets et Evénementielle

Ce document présente des notions fondamentales de programmation orientée objets (POO) en Java, avec un accent sur l'héritage, le polymorphisme, les classes abstraites et la gestion de collections. Il s'adresse aux étudiants en informatique ou en développement logiciel souhaitant comprendre et appliquer ces concepts à travers des exercices pratiques.

Analyse d'un programme Java : hiérarchie de classes, héritage et polymorphisme

Le programme étudié définit une hiérarchie de classes autour de la notion de livre, avec des sous-classes spécialisées comme BD (bande dessinée) et Album (album à colorier). Chaque classe possède des attributs et des méthodes spécifiques.

Classe Livre

• Attributs protégés : titre, auteur, proprietaire (chaînes de caractères), nb_page (entier), prix (double).
• Méthode Acheter(String nom) : assigne le nom du propriétaire.
• Méthode Est_neuf() : retourne true si le livre n'a pas de propriétaire (proprietaire == ""), sinon false.

Classe BD (bande dessinée)

• Hérite de Livre.
• Attribut privé : encouleur (booléen) indiquant si la BD est en couleur.
• Constructeur : initialise les attributs hérités via super(t, a, p, nb) et définit encouleur.
• Méthode Afficher() : affiche les informations du livre (titre, auteur, prix, nombre de pages).

Classe Album

• Hérite de Livre.
• Attribut : tableau booléen page_coloriee[] indiquant quelles pages ont été coloriées.
• Constructeur : initialise les attributs et crée un tableau de pages coloriées initialisé à false.
• Méthode Colorie(int num_page) : permet de colorier une page si le livre est neuf et la page non coloriée.
• Méthode Afficher() : affiche les informations du livre et le propriétaire si existant.

Exemple d'utilisation

BD b1 = new BD("LuckyLuke", "Morris", 10.40, 45, true);
b1.Acheter("moi");
b1.Afficher();

Album a1 = new Album("Dora", "Dora", 300, 3.5);
a1.Afficher();
a1.Colorie(23);
a1.Acheter("moi");
a1.Colorie(23);

Ce programme affiche les informations des livres, gère la propriété et le coloriage des pages pour les albums.

Questions clés

• Encapsulation de l'attribut prix : L'attribut prix est défini sans modificateur d'accès, donc par défaut il est package-private (accessible dans le même package). Le programme modifie directement l1.prix = 0.0 sans erreur.
• Test de nouveauté : Un livre est considéré neuf si proprietaire == "".
• Hiérarchie : Livre est la superclasse, BD et Album en héritent. Les constructeurs des sous-classes appellent super(...) pour initialiser les attributs de la superclasse.
• Coloriage d'une page : Se fait uniquement si le livre est neuf et la page n'a pas encore été coloriée. Sinon, un message d'erreur est affiché.

Extension de la hiérarchie : gestion d'un site de vente de livres et films

Le site vend des livres pour enfants, soit des bandes dessinées, soit des albums à colorier. Les bandes dessinées peuvent être en couleur ou noir & blanc, et les albums permettent de colorier des pages.

Fonctionnalités à implémenter

• Possibilité pour l'utilisateur de revendre un livre.
• Échange de deux bandes dessinées si elles ont un prix équivalent.
• Extension de la hiérarchie pour intégrer des films (DVD) avec titre, auteur, prix et durée.

Ces fonctionnalités nécessitent d'ajouter des méthodes pour la revente et l'échange, ainsi qu'une nouvelle classe pour les films, héritant probablement d'une superclasse commune aux œuvres culturelles.

Programmation d'émissions télévisuelles : héritage, classes abstraites et polymorphisme

Le logiciel gère la programmation journalière d'émissions de trois types : divertissement, fiction, reportage.

Caractéristiques des émissions

• Divertissement : durée fixe de 2 heures, possède un nom et un animateur.
• Fiction : définie par nom du film, année, réalisateur, et indication de rediffusion.
• Reportage : défini par nom, thème (information, animalier, culturel) et durée.

Contraintes de programmation

• Divertissements programmés uniquement entre 18h et 23h.
• Fictions non rediffusées programmées à 21h uniquement, rediffusions à tout moment.
• Reportages programmés à heures creuses (14h-18h et 0h-6h) avec durée ≤ 1 heure.

Approche proposée

• Utilisation d'une classe abstraite pour représenter une émission générique.
• Implémentation du polymorphisme pour gérer la programmation selon le type d'émission.
• Gestion des heures de début et fin de diffusion selon les règles spécifiques.

Exemple d'implémentation

Une classe abstraite Emission avec méthodes abstraites programmer(int heure) et afficher(). Les sous-classes Divertissement, Fiction, Reportage implémentent ces méthodes selon les contraintes.

Gestion d'un programme télé

• Représentation par un tableau d'émissions hétérogènes.
• Algorithmes pour afficher la liste des émissions, vérifier les superpositions, et afficher heure par heure.

Classes abstraites, héritage et collections : points, cercles et cylindres

Ce module introduit la notion de classe abstraite avec une hiérarchie géométrique :

• Forme (classe abstraite) : méthodes abstraites aire(), volume(), afficherNom().
• Point : défini par deux coordonnées réelles x et y. Méthode toString() affiche les coordonnées.
• Cercle : hérite de Point, ajoute un rayon réel. Deux constructeurs : un par défaut (centre (0,0), rayon 0) et un avec paramètres. Méthode aire() calcule 3.14158 * rayon^2.
• Cylindre : hérite de Cercle, ajoute une hauteur réelle. Méthodes aire() et volume() calculées par :

aire = 2 * aire_cercle + 2 * 3.14159 * rayon * hauteur

volume = aire_cercle * hauteur

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

Exemple de test

Point p = new Point(5, 5);
Cercle c = new Cercle(10, 15, 8.5);
Cylindre cy = new Cylindre(30, 30, 12.5, 20);

System.out.println(p.toString());
System.out.println("Aire de Point = " + p.aire() + " et volume = " + p.volume());

System.out.println(c.toString());
System.out.println("Aire de Cercle = " + c.aire() + " et volume = " + c.volume());

System.out.println(cy.toString());
System.out.println("Aire de Cylindre = " + cy.aire() + " et volume = " + cy.volume());

Gestion d'une collection de véhicules avec ArrayList

Un collectionneur souhaite gérer une liste de véhicules (autos, motos, camions) avec les attributs marque, modèle et couleur.

Fonctionnalités demandées

• Afficher la liste des noms des véhicules.
• Afficher tous 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 collection).

Approche orientée objet

• Créer une superclasse Vehicule avec les attributs communs.
• Créer des sous-classes Auto, Moto, Camion.
• Utiliser une ArrayList<Vehicule> pour stocker les véhicules.
• Créer une classe héritant de ArrayList pour ajouter des méthodes spécifiques (filtrage par couleur, recherche, suppression).
• Implémenter une interface graphique affichant chaque véhicule sous forme de bouton, permettant d'afficher ses détails au clic.

Glossaire des termes clés

• Classe abstraite : classe qui ne peut pas être instanciée directement, contenant des méthodes abstraites à implémenter dans les sous-classes.
• Héritage : mécanisme permettant à une classe d'hériter des attributs et méthodes d'une autre classe.
• Polymorphisme : capacité d'un objet à prendre plusieurs formes, notamment par redéfinition de méthodes dans les sous-classes.
• Encapsulation : principe de restreindre l'accès direct aux attributs d'une classe via des modificateurs d'accès (public, private, protected).
• Constructeur : méthode spéciale utilisée pour initialiser un objet lors de sa création.
• ArrayList : collection dynamique en Java permettant de stocker des objets et de les manipuler facilement.
• Itérateur : objet permettant de parcourir une collection élément par élément.
• Méthode toString() : méthode retournant une représentation textuelle d'un objet.
• Superclasse : classe dont héritent d'autres classes.
• Sous-classe : classe qui hérite d'une autre classe.

Points clés à retenir

• La programmation orientée objets repose sur la définition de classes, l'héritage et le polymorphisme pour modéliser des objets complexes.
• Les classes abstraites permettent de définir des interfaces communes tout en laissant les sous-classes implémenter les détails.
• La gestion des collections avec ArrayList facilite le stockage et la manipulation dynamique d'objets hétérogènes.
• Le polymorphisme permet d'écrire du code générique capable de traiter différents types d'objets via une interface commune.
• Les constructeurs et l'appel à super() sont essentiels pour initialiser correctement les objets dans une hiérarchie de classes.
• Les règles métier (ex : contraintes de programmation d'émissions, coloriage de pages) doivent être implémentées dans les méthodes des classes concernées.