Exam on Object-Oriented Programming

Problème : Gestion de personnel

Note préliminaire : L'énoncé original mentionne un diagramme de conception objet qui n'a pas été fourni dans le texte extrait. Pour pouvoir produire un code qui fonctionne et qui soit cohérent d'une question à l'autre, nous allons déduire et supposer les attributs nécessaires à partir du contexte des questions suivantes (notamment les questions 15 et 19 qui précisent certains éléments comme le type de contrat, le sexe de l'employé, les dates et le motif).

Question 1 - Déclaration de la classe Contrat

L'énoncé demande de déclarer la classe Contrat avec ses attributs en visibilité privée. Nous supposerons ici des attributs classiques pour un contrat (identifiant, type de contrat tel que "CDI", et salaire).

public class Contrat {
    private int idContrat;
    private String typeContrat;
    private double salaire;
    
    // Le reste du code sera ajouté aux questions suivantes
}

Question 2 - Constructeur par défaut

Le constructeur sans paramètre permet d'instancier un objet vide.

    public Contrat() {
    }

Question 3 - Constructeur d'initialisation

Ce constructeur prend en paramètre les valeurs nécessaires pour initialiser tous les attributs de la classe.

    public Contrat(int idContrat, String typeContrat, double salaire) {
        this.idContrat = idContrat;
        this.typeContrat = typeContrat;
        this.salaire = salaire;
    }

Question 4 - Notion de méthodes de même nom

Pour déclarer plusieurs méthodes ayant le même nom au sein d'une même classe, il est impératif que leurs signatures soient différentes. Cela implique qu'elles doivent différer par au moins l'un des critères suivants :

• Le nombre de paramètres.
• Le type des paramètres.
• L'ordre des paramètres (si les types sont différents).

Cette notion orientée objet est appelée la surcharge de méthode (ou overloading).

Question 5 - Méthode SaisirContrat()

Cette méthode permet à l'utilisateur de saisir les données au clavier. Nous utilisons la classe Scanner de la bibliothèque standard Java.

    import java.util.Scanner;

    public void SaisirContrat() {
        Scanner sc = new Scanner(System.in);
        
        System.out.println("Veuillez saisir l'identifiant du contrat : ");
        this.idContrat = sc.nextInt();
        
        System.out.println("Veuillez saisir le type de contrat (ex: CDI) : ");
        this.typeContrat = sc.next();
        
        System.out.println("Veuillez saisir le salaire : ");
        this.salaire = sc.nextDouble();
    }

Classe congé

Question 6 - Déclaration de la classe abstraite Conge

La classe Conge est abstraite, implémente une interface et possède des attributs privés (dont les dates, inférées par la question 11, et l'employé, inféré par les questions 15 et 18). Pour faciliter le calcul de la durée, nous utilisons la classe LocalDate.

import java.time.LocalDate;

public abstract class Conge implements OperationConge {
    private LocalDate dateDebut;
    private LocalDate dateFin;
    private Employe employe;
    
    // Le reste du code suit aux questions suivantes
}

(Note : Nous supposons l'existence d'une classe Employe contenant les informations relatives à un employé).

Question 7 - Code source de l'interface OperationConge

Une interface déclare des méthodes qui sont publiques et abstraites par défaut.

public interface OperationConge {
    boolean VerifierConge();
}

Question 8 - Obligation de déclaration de la méthode abstraite

Est-ce obligatoire ? Non. Pourquoi ? Parce que la classe Conge est déclarée avec le mot-clé abstract. En Java, une classe abstraite qui implémente une interface n'est pas obligée de fournir une implémentation pour les méthodes de cette interface, et n'est pas non plus obligée de les redéclarer. Elle transmet simplement l'obligation d'implémentation à la première classe fille concrète qui en héritera.

Question 9 - Méthode AfficherConge()

Cette méthode affiche les informations contenues dans les attributs de la classe Conge.

    public void AfficherConge() {
        System.out.println("Date de début du congé : " + this.dateDebut);
        System.out.println("Date de fin du congé : " + this.dateFin);
        if (this.employe != null) {
            System.out.println("Employé concerné : " + this.employe.getNom());
        }
    }

Question 10 - Accesseurs (getters et setters)

    public LocalDate getDateDebut() {
        return this.dateDebut;
    }

    public void setDateDebut(LocalDate dateDebut) {
        this.dateDebut = dateDebut;
    }

    public LocalDate getDateFin() {
        return this.dateFin;
    }

    public void setDateFin(LocalDate dateFin) {
        this.dateFin = dateFin;
    }

    public Employe getEmploye() {
        return this.employe;
    }

    public void setEmploye(Employe employe) {
        this.employe = employe;
    }

Question 11 - Méthode CalculJourConge()

Pour calculer le nombre de jours successifs entre deux objets LocalDate, nous utilisons ChronoUnit.DAYS.between.

    import java.time.temporal.ChronoUnit;

    public int CalculJourConge() {
        if (this.dateDebut != null && this.dateFin != null) {
            long jours = ChronoUnit.DAYS.between(this.dateDebut, this.dateFin);
            return (int) jours;
        }
        return 0;
    }

Classe CongeMaladie et CongeMaternite

Question 12 - Déclaration de la classe CongeMaternite

La classe hérite de Conge. Nous lui ajoutons l'attribut du nombre de jours maximum mentionné à la question 15.

public class CongeMaternite extends Conge {
    private int maxJoursMaternite;
    
    // Le reste du code suit
}

Question 13 - Constructeur vide CongeMaternite()

Le constructeur par défaut fait appel à celui de la classe mère via super().

    public CongeMaternite() {
        super();
        this.maxJoursMaternite = 90; // Valeur d'exemple classique
    }

Question 14 - Méthode AfficherConge() étendue

Nous utilisons l'annotation @Override et faisons appel à super.AfficherConge() pour réutiliser le code de la classe mère avant d'ajouter l'affichage spécifique.

    @Override
    public void AfficherConge() {
        super.AfficherConge();
        System.out.println("Nombre maximum de jours autorisés : " + this.maxJoursMaternite);
    }

Question 15 - Méthode VerifierConge()

Cette méthode vérifie trois conditions. Nous supposons que la classe Employe dispose des méthodes getSexe() et getContrat(), et que Contrat dispose de getTypeContrat().

    @Override
    public boolean VerifierConge() {
        // Sécurisation contre les références nulles
        if (this.getEmploye() == null || this.getEmploye().getContrat() == null) {
            return false;
        }
        
        String sexe = this.getEmploye().getSexe();
        String typeContrat = this.getEmploye().getContrat().getTypeContrat();
        int joursDemandes = this.CalculJourConge();
        
        if (sexe.equalsIgnoreCase("Féminin") && 
            joursDemandes <= this.maxJoursMaternite && 
            typeContrat.equalsIgnoreCase("CDI")) {
            return true;
        }
        return false;
    }

Classe listConge

Question 16 - Constructeur ListCong(int annee)

Ici, nous devons initialiser un tableau capable de contenir 1000 congés, et mettre le compteur à zéro.

public class ListConge {
    private Conge[] tabConges;
    private int NombreDeCong;
    private int annee;

    public ListConge(int annee) {
        this.annee = annee;
        this.tabConges = new Conge[1000];
        this.NombreDeCong = 0;
    }

Question 17 - Méthode AjouterUnCong(Conge C)

Il faut vérifier que le congé est valide avec VerifierConge(), qu'il reste de la place dans le tableau, puis mettre à jour NombreDeCong.

    public void AjouterUnCong(Conge C) {
        if (C.VerifierConge()) {
            if (this.NombreDeCong < this.tabConges.length) {
                this.tabConges[this.NombreDeCong] = C;
                this.NombreDeCong++;
                System.out.println("Congé ajouté avec succès.");
            } else {
                System.out.println("Erreur : La liste des congés est pleine.");
            }
        } else {
            System.out.println("Erreur : Le congé n'est pas valide et n'a pas été ajouté.");
        }
    }

Question 18 - Méthode CalculCongeEmp(Employe E)

Cette méthode parcourt les congés stockés et additionne la durée si le congé appartient à l'employé passé en paramètre.

    public int CalculCongeEmp(Employe E) {
        int sommeJours = 0;
        for (int i = 0; i < this.NombreDeCong; i++) {
            if (this.tabConges[i].getEmploye().equals(E)) {
                sommeJours += this.tabConges[i].CalculJourConge();
            }
        }
        return sommeJours;
    }

Question 19 - Méthode main()

Pour ce script principal, nous allons simuler les constructeurs d'initialisation complets pour CongeMaladie, CongeMaternite et Employe qui n'ont pas été formellement définis dans les questions précédentes mais qui sont requis par l'énoncé.

    import java.time.LocalDate;

    public static void main(String[] args) {
        // Création d'une nouvelle liste de congés pour l'année 2017
        ListConge TAB2017 = new ListConge(2017);

        // Simulation de la création de l'employé E1 et de son congé de maladie
        // On suppose un constructeur avec (ID, Contrat, Sexe) pour la validation ultérieure
        Contrat contratCDI = new Contrat(1, "CDI", 2500.0);
        Employe E1 = new Employe("E1", contratCDI, "Masculin");
        
        // On suppose un constructeur de CongeMaladie avec (DateDebut, DateFin, Employe, Motif)
        CongeMaladie C1 = new CongeMaladie(
            LocalDate.of(2017, 2, 1), 
            LocalDate.of(2017, 2, 3), 
            E1, 
            "grippe"
        );

        // Simulation de la création de l'employée E2 et de son congé de maternité
        Employe E2 = new Employe("E2", contratCDI, "Féminin");
        
        // On suppose un constructeur de CongeMaternite avec (DateDebut, DateFin, Employe)
        CongeMaternite C2 = new CongeMaternite(
            LocalDate.of(2017, 3, 1), 
            LocalDate.of(2017, 3, 30), 
            E2
        );

        // Ajout des deux congés à la liste TAB2017
        TAB2017.AjouterUnCong(C1);
        TAB2017.AjouterUnCong(C2);
    }
} // Fin de la classe ListConge

Méthode

Face à ce type d'épreuve de programmation orientée objet sur papier, voici la stratégie à adopter :

1. Identifier les données manquantes : Il est courant qu'un énoncé fasse référence à un diagramme absent ou oublie de demander l'implémentation de certaines classes basiques (ici, Employe ou CongeMaladie). Dans ce cas, écrivez sur votre copie que vous postulez l'existence de ces classes/attributs, en leur attribuant le comportement le plus logique possible.
2. Garder en tête la hiérarchie des classes : Avant de coder, visualisez l'héritage : Conge (Abstraite) implémente OperationConge et se divise en CongeMaladie et CongeMaternite. Les comportements hérités (super) doivent être systématiquement exploités plutôt que réécrits.
3. Faire attention aux validations croisées : Dans la question 15, on vous demande de vérifier un sexe, une durée et un type de contrat. Cela signifie que la classe sur laquelle vous travaillez (CongeMaternite) a impérativement besoin d'avoir accès à une instance d'Employe, et que cet employé doit posséder une instance de Contrat. La maîtrise des "getters" en cascade (ex: this.getEmploye().getContrat().getTypeContrat()) est essentielle ici.
4. Dates et temps en Java : Bien qu'il soit possible dans un devoir sur table d'utiliser des chaînes de caractères (Strings) rudimentaires pour représenter une date et faire une soustraction factice, utiliser l'API temporelle moderne (comme LocalDate introduite dans Java 8) vous assure des calculs stricts et valorise votre copie.