Programmation Orientée Objet (Java): Série n°2 Classes et Objets

Ce TP de programmation orientée objet en Java propose plusieurs exercices pour apprendre à définir et manipuler des classes et objets. Il couvre la création de classes simples comme Coordonnees, Point, Cercle, Book, Library, Client et Compte, ainsi que l’utilisation de tableaux et vecteurs pour gérer des collections d’objets. Ce TP nécessite un environnement Java fonctionnel et des connaissances de base en programmation orientée objet.

Objectifs

• Créer et utiliser des classes avec attributs, constructeurs et méthodes.
• Manipuler des tableaux et vecteurs d’objets.
• Implémenter des méthodes classiques comme toString(), equals(), compareTo().
• Comprendre la gestion des références et la comparaison d’objets.
• Appliquer les concepts d’encapsulation et d’abstraction.

Prérequis et installation

• Environnement Java installé (JDK compatible).
• Connaissances de base en Java : classes, méthodes, attributs, tableaux.
• Éditeur de texte ou IDE pour écrire et compiler du code Java.
• Connaissance des notions de programmation orientée objet.

Exercice 2.1 : Carnet d’adresses

Dans cet exercice, vous allez créer deux classes : Coordonnees et CarnetCoordonnees, regroupées dans le package probleme1. L’objectif est de modéliser un carnet d’adresses simple.

Étapes :

1. Compléter la classe Coordonnees avec les attributs privés nom, prenom, telephone et adresse.
2. Ajouter un constructeur pour initialiser ces attributs.
3. Implémenter une méthode toString() qui retourne une chaîne décrivant les coordonnées.
4. Compléter la classe CarnetCoordonnees avec :
• Un tableau privé carnet pouvant contenir jusqu’à 100 coordonnées.
• Un entier nbCoordonnees pour compter les entrées.
• Un constructeur initialisant un carnet vide.
• La méthode ajouter(Coordonnees c) pour ajouter une nouvelle entrée.
• La méthode rechercher(String nom, String prenom) qui affiche les coordonnées du premier contact correspondant, ou un message si la personne n’existe pas.
• La méthode affiche() pour afficher toutes les coordonnées du carnet.
5. Tester la classe avec la classe TestCarnetCoordonnees fournie, qui crée un carnet, ajoute des entrées, affiche le carnet et recherche une personne.

Résultat attendu : L’affichage des coordonnées ajoutées et la recherche affichant correctement les informations ou un message d’absence.

Exercice 2.2 : Classe Point

Ce TP consiste à créer une classe Point représentant un point dans un plan cartésien avec des coordonnées flottantes.

1. Écrire la classe Point avec les attributs abscisse et ordonnee de type float.
2. Ajouter une méthode afficher() qui imprime les coordonnées du point.
3. Ajouter une méthode deplacer(float dx, float dy) qui modifie les coordonnées selon les pas fournis.
4. Utiliser un constructeur par défaut initialisant le point.
5. Écrire une classe TestPoint qui crée un point, affiche ses coordonnées, le déplace (par exemple abscisse +2.5, ordonnée -1), puis affiche à nouveau.
6. Discuter si on peut déplacer un point sans appeler la méthode deplacer() et si l’appel de cette méthode est toujours possible depuis TestPoint.
7. Étendre la classe Point en ajoutant :
• Un constructeur sans paramètres.
• Un constructeur avec paramètres pour initialiser les coordonnées.
• Les méthodes getAbscisse() et getOrdonnee() pour accéder aux coordonnées.
• Les méthodes setAbscisse(float x) et setOrdonnee(float y) pour modifier les coordonnées.
• Une méthode toString() retournant une chaîne décrivant le point.
• Une méthode compareTo(Point p) retournant un booléen indiquant si les coordonnées de p sont égales à celles de l’objet courant.
8. Modifier TestPoint pour créer deux points : un avec le constructeur paramétré (ex. abscisse=1, ordonnée=2.3) et un avec le constructeur sans paramètres.
9. Déplacer le premier point (abscisse -0.5, ordonnée +0.7), puis faire en sorte que le deuxième point ait les mêmes coordonnées que le premier.
10. Afficher les coordonnées des deux points de deux façons différentes.
11. Comparer les deux points en utilisant l’opérateur == sur leurs références, puis en appelant compareTo().
12. Rendre compareTo() static et refaire la comparaison.
13. Modifier TestPoint pour permettre à l’utilisateur d’entrer les coordonnées et les déplacements via la classe Clavier.
14. Gérer plusieurs points dans un tableau dont la taille est définie par l’utilisateur, et faire confondre le premier et le dernier point du tableau.

Exercice 2.3 : Cercle et Point

Ce TP étend la classe Point pour définir un cercle.

1. Reprendre la classe Point de l’exercice précédent.
2. Écrire la classe Cercle avec deux attributs : un Point centre et un rayon.
3. Ajouter un constructeur initialisant ces attributs.
4. Ajouter une méthode toString() affichant le centre et le rayon.
5. Ajouter une méthode translate(int dx, int dy) qui déplace le cercle en décalant son centre.
6. Ajouter une méthode equals() qui retourne vrai si deux cercles ont le même centre et le même rayon.
7. Ajouter une méthode contains(Point p) qui retourne vrai si le point p est contenu dans le cercle.
8. Analyser le code suivant et expliquer son affichage :

Point p = new Point(1, 2);
Circle c = new Circle(p, 1);
Circle c2 = new Circle(p, 2);
c2.translate(1, 1);
System.out.println(c + " " + c2);

Ce code crée deux cercles avec le même centre initial, puis déplace le second. L’affichage montre les centres et rayons respectifs après translation.

Enfin, écrire une classe Test pour tester tous les comportements des classes Point et Cercle.

Exercice 2.4 : Book

L’objectif est de définir une classe Book représentant un livre avec :

• Un titre (String).
• Un auteur (String).
• Un numéro ISBN (String).
• Un prix (double).

Écrire un constructeur public Book(String title, String author, String isbn, double price) pour initialiser ces attributs.

Réfléchir à la manière de construire une instance de Book en utilisant ce constructeur.

Exercice 2.5 : Une bibliothèque

On modélise une bibliothèque contenant des livres.

1. Définir la classe Library avec :
• Un constructeur prenant en paramètre la capacité maximale (nombre de livres).
• Une méthode int capacity() retournant la capacité.
• Une méthode void add(Book b) pour ajouter un livre.
• Une méthode int size() retournant le nombre de livres présents.
• Une méthode void display() affichant tous les livres.
2. Modifier l’attribut tableau de livres en un vecteur (Vector de java.util).
3. Redéfinir les méthodes add(Book b) et display() pour utiliser le vecteur.

Exercice 2.6 : Comptes clients

Ce TP modélise la relation entre clients d’une banque et leurs comptes.

1. Définir la classe Compte avec :
• Un numéro de compte.
• Un solde.
• Un titulaire (client).
• Des opérations de débit et crédit.
• Un constructeur initialisant un compte avec un montant donné.
• Des méthodes pour afficher ou retourner le numéro, le solde, et le nom/prénom du titulaire.

Définir la classe Client avec :

• Nom et prénom.
• Nombre de comptes.
• Une collection de comptes.
• Méthodes pour connaître son nom, prénom, nombre de comptes, numéro et solde de chaque compte, et le solde global.

Réfléchir aux questions :

• Peut-on ajouter un compte après création d’un client ?
• Y a-t-il un nombre limité de comptes par client ?
• Le nombre maximal de comptes diffère-t-il entre clients ?

Écrire une classe TestBanque qui :

• Gère plusieurs clients dans un tableau.
• Crée plusieurs comptes pour chaque client.
• Effectue des opérations sur certains comptes et affiche les informations nécessaires.

Reprendre les définitions précédentes en utilisant des objets Vector au lieu de tableaux.

Résultats attendus

• Classes fonctionnelles permettant la création, modification et affichage des objets demandés.
• Affichage correct des coordonnées dans le carnet d’adresses et recherche fonctionnelle.
• Points correctement affichés et déplacés, comparaison fonctionnelle entre points.
• Cercles affichés avec leurs centres et rayons, translation effective, égalité et inclusion de points dans un cercle.
• Livres et bibliothèques gérés avec ajout et affichage corrects.
• Comptes clients avec opérations de débit/crédit, affichage des soldes et gestion des collections de comptes.

Pièges courants

• Oublier d’initialiser le tableau ou vecteur dans les constructeurs.
• Ne pas incrémenter correctement le compteur nbCoordonnees dans CarnetCoordonnees.
• Confondre comparaison d’objets (==) et comparaison de contenu (compareTo() ou equals()).
• Ne pas gérer le cas où la recherche dans le carnet ne trouve pas la personne.
• Ne pas respecter la portée des attributs (private) et oublier les accesseurs.
• Dans la classe Point, modifier directement les attributs au lieu d’utiliser les setters peut poser problème si les attributs sont privés.
• Dans la gestion des cercles, ne pas bien copier ou référencer les objets Point peut entraîner des effets de bord lors de la translation.
• Dans l’utilisation des vecteurs, oublier d’importer java.util.Vector ou de gérer la taille dynamique.
• Dans les comptes clients, ne pas synchroniser le nombre de comptes et la collection peut causer des incohérences.