MMaattiièèrree PPrrooggrraammmmaattiioonn OOrriieennttééee OObbjjeett

Exercice 1

Exercice 1 - Classe Point

Dans cet exercice, nous allons créer une classe de base Point avec ses attributs, un constructeur, et des méthodes pour manipuler ses coordonnées.

L'énoncé demande une méthode qui permet d'afficher les coordonnées avant et après translation. Pour respecter cette consigne et les bonnes pratiques de la conception orientée objet, nous allons créer une méthode afficherEtTranslater(double dx, double dy) qui affiche l'état courant, appelle la méthode translation, puis affiche le nouvel état. Nous inclurons également une méthode standard toString() pour faciliter l'affichage du tableau.

public class Point {
    // Attributs de la classe
    private double x;
    private double y;

    // Constructeur pour initialiser les données
    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }

    // Méthode de translation
    public void translation(double dx, double dy) {
        this.x = this.x + dx;
        this.y = this.y + dy;
    }

    // Méthode permettant d'afficher avant et après translation
    public void afficherEtTranslater(double dx, double dy) {
        System.out.println("Avant translation : " + this.toString());
        this.translation(dx, dy);
        System.out.println("Après translation : " + this.toString());
    }

    // Surcharge de toString() pour un affichage propre
    public String toString() {
        return "(" + this.x + ", " + this.y + ")";
    }

    // Méthode main pour le test
    public static void main(String[] args) {
        // Test simple
        Point p1 = new Point(2.0, 3.5);
        p1.afficherEtTranslater(1.0, -1.5);
        
        System.out.println("\n--- Affichage du tableau de Points ---");
        
        // Création et affichage d'un tableau d'objets Point
        Point[] tableauPoints = new Point[3];
        tableauPoints[0] = new Point(0, 0);
        tableauPoints[1] = new Point(5, 10);
        tableauPoints[2] = new Point(-3.5, 7.2);

        for (int i = 0; i < tableauPoints.length; i++) {
            System.out.println("Point " + i + " : " + tableauPoints[i].toString());
        }
    }
}

Exercice 2

Exercice 2 - Questions 1 et 2 : Attributs et Constructeur

Nous déclarons les attributs demandés. Le type String sera utilisé pour le nom, prénom, sexe et état civil. Le sexe prendra les valeurs "male" ou "femelle", et l'état civil "célibataire", "marié", ou "veuf".

public class Personne {
    // 1. Attributs
    String nom;
    String prenom;
    String sexe;
    int anneeNaissance;
    String etatCivil;
    boolean conjoint; // true si marié, false sinon

    // 2. Constructeur
    public Personne(String nom, String prenom, String sexe, int anneeNaissance, String etatCivil) {
        this.nom = nom;
        this.prenom = prenom;
        this.sexe = sexe;
        this.anneeNaissance = anneeNaissance;
        this.etatCivil = etatCivil;
        // On déduit automatiquement la variable conjoint
        this.conjoint = etatCivil.equalsIgnoreCase("marié");
    }

Exercice 2 - Question 3 : Méthode retourneInfos()

L'énoncé demande de retourner des messages spécifiques selon le sexe et l'état civil. Attention : l'énoncé demande une méthode void retourneInfos() (qui suggère un affichage direct plutôt qu'un retour de String). Nous allons donc faire des System.out.println dans cette méthode.

    // 3. Méthode retourneInfos
    public void retourneInfos() {
        String titre = "";
        String accordNe = "né";
        String pronom = "il";

        if (this.sexe.equalsIgnoreCase("male")) {
            titre = "M.";
            accordNe = "né";
            pronom = "il";
        } else if (this.sexe.equalsIgnoreCase("femelle")) {
            accordNe = "née";
            pronom = "elle";
            if (this.etatCivil.equalsIgnoreCase("marié") || this.etatCivil.equalsIgnoreCase("mariée")) {
                titre = "Mme.";
            } else {
                titre = "Mlle.";
            }
        }

        System.out.println(titre + " " + this.nom + " " + this.prenom + 
                           " est " + accordNe + " en " + this.anneeNaissance + 
                           ", " + pronom + " est " + this.etatCivil + ".");
    }

Exercice 2 - Question 4 : Calcul de l'âge

L'énoncé demande la signature int age(Personne p). En programmation orientée objet classique, on écrirait plutôt int age(int anneeActuelle) pour calculer l'âge de l'instance courante (this). Toutefois, pour respecter strictement la signature demandée, nous allons traiter l'objet passé en paramètre. L'année universitaire étant 2019-2020, nous utiliserons 2020 comme année de référence.

    // 4. Calcul de l'âge
    public int age(Personne p) {
        int anneeActuelle = 2020;
        return anneeActuelle - p.anneeNaissance;
    }

Exercice 2 - Question 5 : Méthode marier

La consigne demande la signature void marier(Personne p1, Personne p2). Il est judicieux de la déclarer static car elle agit sur deux objets distincts et gère l'interaction entre eux sans privilégier l'un ou l'autre comme instance d'appel.

La méthode doit vérifier qu'il s'agit bien d'un homme et d'une femme, et qu'ils ne sont pas déjà mariés.

    // 5. Méthode pour marier deux personnes
    public static void marier(Personne p1, Personne p2) {
        // Vérification si l'un d'eux est déjà marié
        if (p1.conjoint || p2.conjoint) {
            System.out.println("Erreur : l'une des deux personnes est déjà mariée.");
            return;
        }

        Personne homme = null;
        Personne femme = null;

        // Identification de l'homme et de la femme
        if (p1.sexe.equalsIgnoreCase("male") && p2.sexe.equalsIgnoreCase("femelle")) {
            homme = p1;
            femme = p2;
        } else if (p2.sexe.equalsIgnoreCase("male") && p1.sexe.equalsIgnoreCase("femelle")) {
            homme = p2;
            femme = p1;
        } else {
            System.out.println("Erreur : Le mariage requiert un homme et une femme dans ce système.");
            return;
        }

        // Mise à jour de l'état civil
        homme.etatCivil = "marié";
        homme.conjoint = true;
        
        femme.etatCivil = "mariée";
        femme.conjoint = true;
        
        // Changement de nom pour la femme (Nom époux + Nom jeune fille)
        femme.nom = homme.nom + " " + femme.nom;
    }

Exercice 2 - Question 6 : Programme principal (Test)

Nous ajoutons la méthode main pour tester la classe complète.

    // 6. Test dans le main
    public static void main(String[] args) {
        // Création des deux instances
        Personne p1 = new Personne("ABIDI", "Ali", "male", 1975, "célibataire");
        Personne p2 = new Personne("ALLANI", "Wassila", "femelle", 1980, "célibataire");

        System.out.println("--- Avant le mariage ---");
        p1.retourneInfos();
        p2.retourneInfos();

        // Appel de la méthode de mariage
        System.out.println("\n--- Célébration du mariage ---");
        Personne.marier(p1, p2);

        System.out.println("\n--- Après le mariage ---");
        p1.retourneInfos();
        p2.retourneInfos();
    }
} // Fin de la classe Personne

Exercice 3

Exercice 3 - Représentation des dates

Nous créons la classe Date en respectant l'encapsulation (variables private) et en intégrant l'expression booléenne fournie par l'énoncé pour valider la date dans le constructeur. L'expression de l'énoncé a été recopiée exactement telle quelle.

public class Date {
    // Variables d'instance privées
    private int jour;
    private int mois;
    private int an;

    // Constructeur avec vérification
    public Date(int jour, int mois, int an) {
        // Expression booléenne fournie dans l'énoncé
        boolean dateInvalide = mois < 1 || mois > 12|| jour < 1 || jour > 31|| 
                               jour > 30 && (mois == 4 || mois == 6 || mois == 9 || mois == 11)|| 
                               jour > 29 && mois == 2|| 
                               jour > 28 && mois == 2 && !(an % 4 == 0 && an % 100 != 0 || an % 400 == 0);

        if (dateInvalide) {
            System.out.println("Erreur : La date saisie (" + jour + "/" + mois + "/" + an + ") est incohérente.");
            // Initialisation par défaut en cas d'erreur pour éviter des états imprévisibles
            this.jour = 1;
            this.mois = 1;
            this.an = 2000;
        } else {
            this.jour = jour;
            this.mois = mois;
            this.an = an;
        }
    }

    // Accesseurs (Getters)
    public int getJour() {
        return jour;
    }

    public int getMois() {
        return mois;
    }

    public int getAn() {
        return an;
    }

    // Méthode toString : renvoie la date sous forme " 8 /novembre /2019"
    public String toString() {
        String[] nomsMois = {
            "Erreur", "janvier", "février", "mars", "avril", "mai", "juin", 
            "juillet", "août", "septembre", "octobre", "novembre", "décembre"
        };
        
        return " " + this.jour + " /" + nomsMois[this.mois] + " /" + this.an;
    }

    // Comparaison : true si 'this' est antérieure ou égale à 'd'
    public boolean infeg(Date d) {
        if (this.an < d.getAn()) {
            return true;
        } else if (this.an > d.getAn()) {
            return false;
        } else {
            // Même année, on compare le mois
            if (this.mois < d.getMois()) {
                return true;
            } else if (this.mois > d.getMois()) {
                return false;
            } else {
                // Même année, même mois, on compare le jour
                return this.jour <= d.getJour();
            }
        }
    }
}

Méthode

Face à ce type d'épreuve de Programmation Orientée Objet (POO), voici comment procéder efficacement :

1. Lisez les signatures demandées avant de coder : Des méthodes comme int age(Personne p) ou void marier(Personne p1, Personne p2) vous obligent parfois à utiliser des paramètres que vous auriez pu gérer différemment. Ne modifiez jamais la signature (le nom, le type de retour, les paramètres) imposée par l'énoncé. Adaptez simplement votre implémentation pour que la méthode fasse le travail requis.
2. Respectez l'encapsulation : L'exercice 3 précise variables d'instance privées. Cela signifie que vous ne pouvez y accéder de l'extérieur qu'à travers les getters fournis (getJour(), etc.). Même dans infeg(Date d), il est de bonne pratique d'utiliser d.getAn() plutôt que d.an, bien que Java permette l'accès direct aux variables privées au sein de la même classe.
3. Réutilisez le code fourni : La condition booléenne sur les années bissextiles de l'exercice 3 est complexe. L'énoncé précise "Vous pouvez vous contenter de la copier-coller" ; faites-le. Un examen évalue vos compétences en conception objet, et non pas toujours votre mémorisation des lois calendaires grégoriennes.
4. Testez scrupuleusement les conditions logiques complexes : Pour la comparaison de dates (infeg), l'astuce classique est de tester l'unité la plus large (l'année), puis de descendre progressivement vers les unités plus fines (le mois, puis le jour) uniquement s'il y a égalité à l'étape précédente. Cela permet un code propre et facilement lisible, sans recourir à des formules mathématiques de conversion en jours absolus.