Java Object-Oriented Programming Exercise

Ce TP propose de s'initier à la programmation orientée objet en Java à travers deux exercices principaux : la manipulation de polygones réguliers et la modélisation de formes géométriques simples (points, cercles, segments). Il s'agit d'écrire des classes, d'implémenter des méthodes, de tester des objets et d'explorer le polymorphisme. Pour réaliser ce TP, un environnement Java avec un IDE comme Eclipse est nécessaire.

Objectifs

• Créer et manipuler des classes Java avec variables d'instance et de classe, constructeurs, accesseurs et mutateurs.
• Redéfinir la méthode toString pour afficher les caractéristiques des objets.
• Calculer des propriétés géométriques comme le périmètre d'un polygone ou la distance entre points.
• Utiliser le polymorphisme via une interface et ses implémentations.
• Comparer des objets selon des critères spécifiques (périmètre).
• Manipuler des tableaux d'objets polymorphes et les afficher.

Prérequis et installation

• Connaissances de base en Java : classes, objets, méthodes, variables, constructeur.
• Compréhension du concept de polymorphisme et d'interface en Java.
• Environnement de développement Java (JDK + IDE comme Eclipse).
• Création d'un nouveau projet Java nommé TD2 pour organiser les fichiers sources.

Exercice 1 : Manipulation de polygones réguliers

Dans cet exercice, on travaille uniquement avec des polygones dont tous les côtés ont la même longueur. L'objectif est d'écrire une classe Polygone et de manipuler ses objets pour gérer leur création, affichage, modification et comparaison.

Étape 1 : Déclaration de la classe Polygone et création d'objets

Écrire la classe Polygone avec :

• Une variable de classe pour compter le nombre de polygones créés.
• Des variables d'instance pour le nombre de côtés et la longueur d'un côté.
• Un constructeur par défaut et un constructeur avec paramètres.
• Des accesseurs (getters) et mutateurs (setters) pour les variables d'instance.

Écrire une classe Principal contenant la méthode main qui instancie deux polygones et teste tous les accesseurs.

Un résultat correct montre que les objets sont créés avec les bonnes valeurs et que les accesseurs retournent les valeurs attendues.

Étape 2 : Redéfinition de la méthode toString

Redéfinir la méthode toString de la classe Object dans la classe Polygone pour afficher les caractéristiques du polygone (nombre de côtés, longueur d'un côté).

Modifier la méthode main pour afficher les caractéristiques des deux polygones créés à l'étape précédente.

Un affichage correct doit présenter clairement les informations de chaque polygone.

Étape 3 : Calcul du périmètre

Écrire la méthode perim dans la classe Polygone qui initialise une variable d'instance correspondant au périmètre du polygone (nombre de côtés × longueur d'un côté).

Modifier les constructeurs pour que cette variable soit initialisée dès la création de l'objet.

Modifier la méthode toString pour afficher également le périmètre.

Un résultat correct montre que le périmètre est calculé et affiché correctement pour chaque polygone.

Étape 4 : Création d'un polygone modifié

Écrire la méthode presqueClone qui crée un nouveau polygone en ajoutant ou en enlevant des côtés à un polygone existant.

Modifier la méthode main pour :

• Demander à l'utilisateur le nombre de côtés à ajouter ou enlever.
• Créer un nouveau polygone modifié à partir d'un des deux polygones existants.
• Afficher les caractéristiques du nouveau polygone.

Un résultat correct montre que le nouveau polygone a le bon nombre de côtés, la même longueur de côté, et que ses caractéristiques sont affichées.

Étape 5 : Comparaison de polygones

Écrire la méthode plusPetit qui compare deux polygones et retourne celui qui a le plus petit périmètre.

Modifier la méthode main pour afficher les caractéristiques du polygone ayant le plus petit périmètre parmi les polygones créés.

Un résultat correct affiche clairement le polygone avec le périmètre le plus faible.

Exercice 2 : Dessiner des formes géométriques simples

Ce second exercice consiste à modéliser des formes géométriques simples : points, cercles, segments, et à utiliser une interface Forme pour gérer leur dessin et calcul de centre.

Étape 1 : Classe Point

Écrire la classe Point avec :

• Variables d'instance pour les coordonnées x et y (réelles).
• Constructeur pour initialiser ces coordonnées.
• Accesseurs pour x et y.

Redéfinir la méthode toString pour afficher un point sous la forme (x, y).

Écrire une classe avec main qui crée deux points pour les utiliser dans la suite.

Un résultat correct affiche les coordonnées des deux points.

Étape 2 : Classe Cercle

Écrire la classe Cercle avec :

• Une variable d'instance pour le centre (de type Point).
• Une variable d'instance pour le rayon.
• Un constructeur pour initialiser ces variables.

Redéfinir la méthode toString pour afficher : « Cercle de centre (x, y) et de rayon r ».

Modifier la méthode main pour créer un cercle à partir d'un des points précédemment créés et d'un rayon donné par l'utilisateur.

Un résultat correct affiche les caractéristiques du cercle.

Étape 3 : Classe Segment

Écrire la classe Segment avec :

• Variables d'instance pour les deux points extrémités.
• Constructeur pour initialiser ces points.
• Accesseurs pour ces variables.

Redéfinir la méthode toString pour afficher : « Segment délimité par les points (x1, y1) et (x2, y2) ».

Modifier la méthode main pour créer un segment à partir des deux points créés précédemment.

Un résultat correct affiche les caractéristiques du segment.

Étape 4 : Interface Forme

Écrire l'interface Forme qui déclare deux méthodes abstraites :

• centre : retourne un Point représentant le centre de la forme.
• dessine : effectue un affichage.

Dans la classe Cercle :

• Implémenter la méthode centre qui retourne le centre du cercle.
• Écrire une méthode longueur qui calcule la circonférence (2 × π × rayon).
• Implémenter la méthode dessine qui affiche « Au compas : » suivi des caractéristiques du cercle (via toString).

Dans la classe Segment :

• Implémenter la méthode centre qui retourne le milieu du segment.
• Écrire une méthode longueur qui calcule la longueur du segment (distance entre les deux points).
• Implémenter la méthode dessine qui affiche « A la règle : » suivi des caractéristiques du segment (via toString).

Dans la classe contenant main :

• Déclarer un tableau de trois Forme.
• Placer dans ce tableau : le cercle en première position, le segment en deuxième, et un nouveau segment ou cercle en troisième position.
• « Dessiner » toutes les formes en appelant leur méthode dessine.

Un résultat correct affiche les messages de dessin pour chaque forme avec leurs caractéristiques.

Étape 5 : Constructeur supplémentaire dans Cercle

Écrire un nouveau constructeur dans la classe Cercle :

public Cercle(Segment unSeg);

Ce constructeur crée un cercle dont le segment donné est le diamètre. Il doit faire appel au constructeur précédent de Cercle.

Modifier la classe main pour :

• Ajouter une 4ème case au tableau des formes.
• Initialiser cette case avec le cercle créé à partir du segment déjà créé.
• « Dessiner » toutes les formes du tableau.

Un résultat correct affiche les quatre formes avec leurs caractéristiques et les messages de dessin associés.

Résultats attendus

• Création correcte des polygones avec comptage du nombre d'instances.
• Affichage clair des caractéristiques des polygones, incluant le périmètre.
• Création d'un polygone modifié avec le bon nombre de côtés.
• Identification correcte du polygone au plus petit périmètre.
• Affichage des points, cercles et segments avec leurs coordonnées et dimensions.
• Fonctionnement des méthodes centre, longueur et dessine dans les classes implémentant Forme.
• Affichage des messages « Au compas : » ou « A la règle : » suivi des caractéristiques des formes.
• Gestion correcte du tableau polymorphe de formes et affichage de toutes les formes.

Pièges courants

• Oublier d'incrémenter la variable de classe qui compte les polygones lors de la création.
• Ne pas initialiser la variable périmètre dans tous les constructeurs, ce qui peut causer des valeurs incorrectes.
• Confondre les coordonnées x et y dans les affichages ou calculs.
• Ne pas redéfinir toString, ce qui rend l'affichage des objets peu lisible.
• Dans presqueClone, ne pas gérer correctement l'ajout ou la suppression de côtés, ce qui peut créer des polygones invalides.
• Ne pas respecter la signature exacte des méthodes de l'interface Forme, empêchant la compilation.
• Oublier d'appeler le constructeur existant dans le nouveau constructeur Cercle(Segment unSeg).
• Ne pas initialiser toutes les cases du tableau de Forme avant de les utiliser.
• Dans la méthode dessine, oublier d'appeler toString pour afficher les caractéristiques.