Introduction to Object-Oriented Programming in Java

Ce laboratoire d'introduction à la programmation orientée objet en Java propose plusieurs exercices pratiques pour apprendre à définir et manipuler des classes représentant des objets du quotidien ou mathématiques. Vous apprendrez à créer des classes avec variables d'instance, constructeurs, méthodes d'accès, méthodes de modification, et à tester ces classes via une méthode main. Les exercices couvrent des exemples variés : articles de supermarché, dates, flacons de sirop, points géométriques, rectangles, et fractions. Pour suivre ce TP, il faut disposer d'un environnement Java fonctionnel et connaître les bases de la syntaxe Java.

Objectifs

• Savoir définir une classe Java avec variables d'instance privées et méthodes publiques.
• Créer des constructeurs et des méthodes d'accès (getters) et de modification.
• Implémenter des méthodes spécifiques : calculs, comparaisons, transformations géométriques.
• Tester les classes via une méthode main avec des tableaux et appels de méthodes.
• Comprendre la notion de clonage d'objets et ses implications.
• Manipuler des types complexes comme BigInteger pour éviter les débordements.

Prérequis et installation

• Un environnement Java JDK installé (version non précisée mais compatible avec java.util.Calendar).
• Connaissances de base en Java : classes, méthodes, variables, types primitifs et objets.
• Connaissance des notions mathématiques simples : coordonnées cartésiennes et polaires, fractions.
• Éviter les importations génériques du type import monPackage.*; pour ne pas créer de conflits.

Définition de la classe Article (articles du supermarché)

Écrivez une classe Article avec quatre variables d'instance privées :

• private long reference : numéro unique de l'article
• private String intitule : description textuelle
• private float prixHT : prix unitaire hors taxes
• private int quantiteEnStock : nombre d'unités disponibles

Implémentez les méthodes suivantes :

• Constructeur public Article(long reference, String intitule, float prixHT, int quantiteEnStock) pour initialiser les variables.
• Accesseurs getReference(), getIntitule(), getQuantiteEnStock().
• approvisionner(int nombreUnites) pour augmenter la quantité en stock.
• vendre(int nombreUnites) qui diminue la quantité si possible et renvoie true ou false sinon.
• prixHT() et prixTTC() pour calculer les prix hors taxes et toutes taxes comprises.
• toString() pour afficher la référence, l’intitulé et le prix.
• equals(Article unArticle) pour comparer deux articles selon leur référence.

Testez cette classe avec une méthode main qui crée un tableau d’au moins trois articles et appelle toutes les méthodes.

Création de la classe Date

Écrivez une classe Date avec quatre variables d’instance privées :

• int annee (non négatif)
• int mois (entre 1 et 12)
• int jour (selon le mois)
• int jourSemaine (0 = lundi, 1 = mardi, etc.)

Implémentez :

• Constructeur public Date(int jour, int mois, int annee) qui vérifie la validité des valeurs et calcule le jour de la semaine. En cas d’erreur, affiche un message et arrête le programme avec System.exit(int).
• Accesseurs getJour(), getMois(), getAnnee(), getJourSemaine().
• toString() qui renvoie une chaîne comme "vendredi 8 décembre 2006".
• infeg(Date d) qui renvoie true si la date courante est antérieure ou égale à d.

Pour la validité, utilisez la condition suivante (année bissextile si divisible par 4) :

boolean dateInvalide = mois < 1 || mois > 12
       || jour < 0 || jour > 31
       || (jour == 31 && (mois == 4 || mois == 6 || mois == 9 || mois == 11))
       || (jour >= 30 && mois == 2)
       || (jour == 29 && mois == 2 && annee % 4 != 0);

Pour calculer le jour de la semaine, vous pouvez utiliser :

private int jourSemaine(int jour, int mois, int annee) {
    Calendar c = Calendar.getInstance();
    c.set(annee, mois - 1, jour);
    return (c.get(java.util.Calendar.DAY_OF_WEEK) + 5) % 7;
}

Attention à ne pas importer java.util.* pour éviter les conflits avec votre classe Date.

Classe Flacon pour le sirop Mirifik

Créez une classe Flacon avec :

• private final float capacite (capacité en ml)
• private float volume (volume actuel en ml)
• private float concentration (rapport volume sirop / volume total)
• String etiquette (texte affiché sur le flacon)

Méthodes à implémenter :

• Constructeur public Flacon(String etiquette, float capacite) : volume initialisé à zéro.
• verser(float volumeSirop, float volumeEau) : ajoute les volumes indiqués, vérifie la possibilité, sinon affiche un message et arrête le programme.
• transvaser(Flacon autreFlacon, float volume) : transfert un volume d’un autre flacon, avec vérification et arrêt en cas d’impossibilité.
• toString() : affiche l’étiquette, le volume et la concentration.

Testez toutes ces opérations dans une méthode main.

Réfléchissez à l’intérêt des qualifieurs final pour capacite et private pour volume et concentration.

Classe Point et LignePol (points du plan et lignes polygonales)

Définition de Point

Créez une classe Point avec deux variables d’instance privées (double) x et y représentant les coordonnées cartésiennes.

Méthodes publiques :

• Constructeur Point(double x, double y)
• double x() et double y() pour obtenir les coordonnées
• double r() et double t() pour obtenir les coordonnées polaires (r = sqrt(x² + y²), t = atan2(y, x))
• String toString() renvoyant "(x,y)"
• boolean equals(Object o) pour comparer deux points
• void homothetie(double k) : applique une homothétie de centre (0,0) et rapport k
• void translation(double dx, double dy) : applique une translation
• void rotation(double a) : applique une rotation d’angle a autour de (0,0) en recalculant les coordonnées polaires puis cartésiennes

Définition de LignePol

Créez une classe LignePol représentant une ligne polygonale définie par un tableau de points :

• Point[] sommets : tableau des sommets
• int nbSommets : nombre de sommets (égal à sommets.length)

Méthodes publiques :

• LignePol(int n) : constructeur avec n sommets indéterminés
• LignePol(Point[] sommets) : constructeur avec sommets donnés
• Point getSommet(int i) et void setSommet(int i, Point p)
• String toString() : expression textuelle de la ligne polygonale
• void homothetie(double k), void translation(double dx, double dy), void rotation(double a) : appliquent les transformations à tous les sommets

Ajoutez une méthode tracer() simulant le tracé de la ligne polygonale en appelant :

void tracerLigne(int x0, int y0, int x1, int y1) {
    System.out.println("tracer de (" + x0 + "," + y0 + ") à (" + x1 + "," + y1 + ")");
}

Écrivez une méthode main qui construit et trace une figure polygonale (exemple : une cocotte).

Représentation polaire interne de Point

Réécrivez la classe Point pour stocker les coordonnées en polaires (r, t) au lieu de cartésiennes, mais en conservant la même interface publique. Ainsi, les classes utilisant Point (comme LignePol) fonctionneront sans modification.

Objets membres d’autres objets : classe Rectangle

En partant d’une classe Point simple (sans constructeur sans arguments), définissez une classe Rectangle avec :

• private Point coinNO (coin Nord-Ouest)
• private Point coinSE (coin Sud-Est)

Méthodes :

• Constructeur Rectangle(double x0, double y0, double x1, double y1)
• toString() renvoyant une chaîne comme "[(x0,y0);(x1,y1)]"

Testez le comportement suivant :

public static void main(String[] args) {
    Rectangle r1, r2;
    r1 = new Rectangle(1, 2, 3, 4);
    r2 = r1;
    System.out.println("r1: " + r1 + ", r2: " + r2);
    r1.coinNO = new Point(0, 0);
    System.out.println("r1: " + r1 + ", r2: " + r2);
    r1.coinSE.homothetie(2);
    System.out.println("r1: " + r1 + ", r2: " + r2);
}

Observez que r2 = r1; ne crée pas une copie indépendante mais une référence au même objet.

Modifiez la classe pour qu’elle implémente Cloneable et changez la ligne r2 = r1; en :

r2 = (Rectangle) r1.clone();

Testez à nouveau et observez le comportement.

Ajoutez la méthode suivante à Rectangle :

public Rectangle clone() {
    return new Rectangle(coinNO.x(), coinNO.y(), coinSE.x(), coinSE.y());
}

Refaites le test et constatez que cette méthode crée une copie indépendante des points.

Classe Fraction

Définissez une classe Fraction pour représenter des fractions avec numérateur et dénominateur de type BigInteger afin d'éviter les débordements.

Méthodes à implémenter :

• public Fraction(BigInteger num, BigInteger den) : constructeur basique
• public Fraction(int n, int d) : conversion d’entiers en BigInteger
• public Fraction(int n) : fraction entière avec dénominateur 1
• add(Fraction f), sub(Fraction f), mult(Fraction f), divi(Fraction f) : opérations arithmétiques
• toString() : conversion en chaîne de caractères
• doubleValue() : approximation décimale

Cette classe permet de manipuler des fractions sans risque de débordement des entiers.

Résultats attendus

• Les classes doivent compiler sans erreur et fonctionner selon les spécifications.
• Les méthodes toString() doivent produire des chaînes lisibles et correctes.
• Les méthodes de comparaison doivent renvoyer les bons booléens.
• Les transformations géométriques doivent modifier les points ou lignes polygonales comme attendu.
• Les méthodes de clonage doivent produire des copies indépendantes des objets.
• Les opérations sur fractions doivent respecter les règles arithmétiques et éviter les débordements.
• Les erreurs de saisie (dates invalides, volumes dépassant la capacité) doivent entraîner un message et l'arrêt du programme.

Pièges courants

• Confusion entre affectation de référence et duplication d’objet (exemple avec r2 = r1;).
• Oublier de vérifier la validité des dates ou des volumes avant modification.
• Ne pas respecter la visibilité private des variables d’instance, ce qui nuit à l’encapsulation.
• Utiliser import java.util.*; provoquant des conflits entre java.util.Date et la classe Date définie.
• Calcul incorrect du jour de la semaine si on ne corrige pas l’indice retourné par Calendar.get(Calendar.DAY_OF_WEEK).
• Ne pas respecter la signature officielle de la méthode equals(Object o) dans les classes.
• Ne pas gérer correctement la capacité maximale dans la classe Flacon lors des ajouts ou transferts.
• Oublier de convertir les entiers en BigInteger dans la classe Fraction.