Java Practical Work

Ce travaux pratiques (TP) propose une série d'exercices de programmation en Java visant à maîtriser les concepts fondamentaux du langage orienté objet. Il couvre la création et manipulation de classes, la gestion des tableaux, les chaînes de caractères, l'héritage, le polymorphisme, les interfaces, ainsi que la gestion des exceptions. Pour réaliser ce TP, un environnement de développement Java est nécessaire, ainsi que des connaissances de base en programmation Java.

Objectifs

• Éditer, compiler et exécuter des programmes Java simples.
• Comprendre et appliquer les principes de la programmation orientée objet : classes, objets, encapsulation.
• Manipuler les tableaux triés et les chaînes de caractères.
• Mettre en œuvre l'héritage, le polymorphisme et les interfaces.
• Gérer les exceptions pour rendre les programmes robustes.
• Visualiser la documentation Java et comprendre l'organisation des packages.

Prérequis et installation

• Un environnement de développement Java (exemple : Microsoft J++ ou tout autre IDE Java).
• Connaissances de base en programmation Java, notamment la syntaxe, les types de données et les structures de contrôle.
• Compréhension des concepts de base de la programmation orientée objet.
• Pour certains exercices, savoir utiliser la ligne de commande pour passer des arguments aux programmes.

Première étape : Édition, compilation et exécution des programmes

Éditez, compilez et exécutez tous les programmes du TD n°1 avec votre environnement Java. Cette étape permet de se familiariser avec l'outil et de vérifier que tout fonctionne correctement.

Remarque importante pour Microsoft J++ : pour visualiser le résultat, ajoutez une saisie clavier afin que la console ne se ferme pas immédiatement. Pour cela :

public static void main (String [] args) throws java.io.IOException {
  ...
  System.in.read();
}

Cette instruction bloque la fin du programme en attendant une saisie clavier.

Deuxième étape : Visualisation de la documentation Java

Explorez la documentation Java pour :

• Visualiser l’ensemble des packages, qui sont des ensembles de classes organisées par domaine d’application.
• Visualiser le package java.lang, qui contient les classes de base du langage.

Troisième étape : Création et manipulation d’une classe Date

Créez une classe Date permettant de représenter une date au format jour/mois/année (exemple : 16/03/1998). Cette classe doit contenir les méthodes suivantes :

• nombreJours() : retourne le nombre de jours du mois de la date.
• dateValide() : vérifie si la date est valide.
• lendemain() : retourne la date du lendemain.

Respectez le principe d'encapsulation en déclarant les attributs privés et en fournissant des méthodes d'accès si nécessaire.

Ensuite, créez une classe TesterDate avec une méthode main qui :

• Crée une date à partir des valeurs jour, mois et année passées en arguments de la ligne de commande.
• Affiche cette date au format jour/mois/année.
• Si la date est valide, affiche le nombre de jours du mois et la date du lendemain.
• Sinon, affiche un message d’erreur.

Pour convertir une chaîne en entier, utilisez :

n = Integer.parseInt(s);

Quatrième étape : Classe Point et calcul de distance

Créez une classe Point avec deux attributs privés x et y (double). Le constructeur doit initialiser ces coordonnées.

Implémentez une méthode statique distance(Point p1, Point p2) qui calcule la distance entre deux points selon la formule :

d = sqrt((x2 - x1)^2 + (y2 - y1)^2)

Utilisez les méthodes statiques de la classe Math :

• Math.sqrt(double nb) pour la racine carrée.
• Math.pow(double nb, double puissance) pour la puissance.

Ajoutez une méthode affiche(int n) qui affiche les coordonnées sous la forme : pN = (x , y).

Cinquième étape : Gestion d’un tableau trié d’entiers

Créez une classe TableauTrie avec un attribut privé tableau d’entiers et un entier représentant le nombre d’éléments.

Prévoyez deux constructeurs :

• Un constructeur prenant la taille du tableau en paramètre.
• Un constructeur sans paramètre qui alloue un tableau de taille 100.

Implémentez les méthodes :

• void inserer(int entier) : insère un entier dans le tableau en respectant l’ordre croissant.
• void retirer(int entier) : retire une occurrence de l’entier donné s’il existe.
• void affiche() : affiche le contenu du tableau précédé du message « Nouveau affichage : ».

Créez une classe EssaiTableauTrie avec la méthode main qui teste la classe :

• Créer un tableau de taille 10.
• Insérer successivement les valeurs 1, 3, 4.
• Afficher le tableau.
• Insérer 2, puis afficher.
• Insérer 0, puis afficher.
• Insérer 1, puis afficher.
• Retirer 1, puis afficher.
• Retirer 0, puis afficher.
• Retirer 4, puis afficher.

Sixième étape : Manipulation des chaînes de caractères avec un carnet d’adresses

Créez une classe Coordonnees avec les attributs privés :

• nom, prénom, téléphone, adresse (tous de type String).

Ajoutez un constructeur initialisant ces champs et des méthodes d’accès (getters).

Créez une classe CarnetCoordonnees avec :

• Un tableau privé de Coordonnees nommé carnet.
• Un entier privé nbCoordonnees indiquant le nombre d’éléments.
• Un constructeur initialisant un carnet vide pouvant contenir 100 coordonnées.
• Une méthode ajouterCoordonnees(Coordonnees c) pour ajouter une entrée.
• Une méthode chercherCoordonnees(String nom, String prenom) qui recherche et affiche le téléphone et l’adresse d’une personne, ou un message d’erreur si non trouvée.
• Une méthode affiche() qui affiche toutes les coordonnées du carnet.

Testez avec la classe fournie qui ajoute plusieurs coordonnées et effectue des recherches.

Septième étape : Héritage et polymorphisme avec une bibliothèque de documents

Application 1 :

• Créez une classe Document avec les attributs titre, numId, nbPages.
• Un constructeur par défaut initialisant titre = "X", numId = -1, nbPages = 0.
• Une méthode edition() affichant les attributs.
• Un second constructeur prenant en paramètres le titre, le numéro et le nombre de pages.
• Dans la méthode main, créez un objet Document selon le nombre d’arguments passés en ligne de commande.

Application 2 :

• Créez les classes suivantes héritant de Document :
• Article avec un attribut Auteur.
• Livre héritant de Article avec un attribut Editeur.
• Periodique avec un attribut Frequence (valeurs possibles : "Mensuel", "Hebdo", "Quotidien").

Chaque classe redéfinit la méthode edition() pour afficher son type et ses caractéristiques.

Créez une classe Biblio qui contient un tableau de Document et gère l’ajout et l’affichage des documents.

Testez avec la classe Tp2_2 fournie qui ajoute des documents variés et affiche le contenu.

Huitième étape : Classes abstraites et interfaces

Complétez le programme suivant :

• Une interface Son avec la méthode void parle().
• Une classe abstraite Mammifere implémentant Son, avec les attributs nom, son, age.
• Un constructeur initialisant ces attributs.
• Une méthode parle() affichant le son et les informations du mammifère.
• Une méthode abstraite vitesse() à implémenter dans les sous-classes.
• Deux classes concrètes Homme et Chien héritant de Mammifere :
• Homme a un attribut marie (boolean) et affiche une vitesse de 20 km/h.
• Chien a un attribut race (String) et affiche une vitesse de 30 km/h.
• Redéfinissez la méthode toString() dans chaque classe pour afficher les informations spécifiques.
• Testez avec la classe Test fournie qui crée un tableau de Son et un tableau de Mammifere et appelle les méthodes polymorphes.

Neuvième étape : Gestion des exceptions

Améliorez le programme de calcul de la factorielle d’un entier passé en argument :

• Attrapez les exceptions suivantes :
• Absence de paramètre (ArrayIndexOutOfBoundsException).
• Paramètre non entier (NumberFormatException).
• Paramètre négatif (exception personnalisée NombreNegatifException).
• Affichez un message d’erreur précis pour chaque cas.
• Si le paramètre est valide et positif, calculez et affichez la factorielle.

Résultats attendus

• Les programmes s’exécutent sans erreur et affichent les résultats attendus selon les spécifications.
• La classe Date valide correctement les dates et calcule le lendemain.
• La classe Point calcule correctement la distance entre deux points.
• La classe TableauTrie insère et retire les entiers tout en maintenant l’ordre croissant.
• Le carnet d’adresses affiche correctement les coordonnées et recherche les entrées.
• Les classes héritées affichent leurs informations spécifiques via la méthode edition().
• Les méthodes polymorphes parle() et vitesse() fonctionnent correctement pour Homme et Chien.
• Le programme de factorielle gère les erreurs d’entrée et affiche des messages clairs.

Pièges courants

• Oublier d’ajouter throws java.io.IOException et System.in.read(); dans main sous Microsoft J++ empêche de voir la sortie.
• Confondre les indices lors de l’insertion et du retrait dans le tableau trié, ce qui peut provoquer des erreurs ou des décalages incorrects.
• Ne pas vérifier la validité des dates avant d’appeler les méthodes sur la classe Date.
• Passer un nombre incorrect d’arguments en ligne de commande sans gérer l’exception correspondante.
• Ne pas utiliser super dans les constructeurs des classes héritées, ce qui empêche d’initialiser correctement les attributs de la superclasse.
• Oublier de redéfinir la méthode abstraite vitesse() dans les sous-classes de Mammifere, ce qui empêche la compilation.
• Ne pas gérer les exceptions dans le programme de factorielle, ce qui peut provoquer un arrêt brutal en cas d’erreur d’entrée.
• Dans la recherche dans le carnet d’adresses, ne pas utiliser equals pour comparer les chaînes de caractères, ce qui fausse la recherche.