Modèle d'examen d'aptitude professionnelle — Accès au grade de technicien de 1er grade — Ministère de l'Agriculture, du Développement Rural et des Pêches Maritimes 2007 — Informatique — Épreuve écrite

Ce modèle est l'épreuve écrite de l'examen d'aptitude professionnelle pour l'accès au grade de technicien de premier grade, option Informatique, Ministère de l'Agriculture, du Développement Rural et des Pêches Maritimes (Direction des Ressources Humaines), session du 9 septembre 2007. Durée : 4 heures, coefficient 4. Un sujet au choix parmi deux. Voici une correction proposée.

Sujet 1 — Base de données : consultations, ordonnances et remboursements

💡 Méthode attendue : Merise. Commencez par le dictionnaire des données et les règles de gestion, puis le MCD, le MLD (relationnel) et le MCT. Les cardinalités sont l'endroit où se perdent le plus de points.

1. Règles de gestion retenues

• RG1 : un membre appartient à une coopérative ; une coopérative compte plusieurs membres.
• RG2 : un médecin a une spécialité ; une spécialité concerne plusieurs médecins.
• RG3 : une consultation concerne un seul membre et un seul médecin, à une date, pour un prix payé.
• RG4 : une consultation donne lieu à 0 ou 1 ordonnance ; une ordonnance contient 1 ou plusieurs médicaments, chacun avec une posologie et une quantité.
• RG5 : un médicament a une forme (sirop, comprimés…) et appartient à une famille (antibiotiques, analgésiques…).
• RG6 : une facture (consultation + ordonnance) est déposée à une mutuelle ; elle donne lieu à un remboursement partiel, après un délai.

2. Modèle conceptuel des données (MCD)

Associations et cardinalités :

• MEMBRE (1,1) — Appartenir — (1,n) COOPERATIVE
• MEDECIN (1,1) — Avoir — (0,n) SPECIALITE
• CONSULTATION (1,1) — Consulter — (0,n) MEMBRE ; CONSULTATION (1,1) — Effectuer — (0,n) MEDECIN
• ORDONNANCE (1,1) — Prescrire — (0,1) CONSULTATION
• ORDONNANCE (1,n) — Contenir [Posologie, Quantité] — (0,n) MEDICAMENT (association porteuse de données)
• MEDICAMENT (1,1) — AvoirForme — (0,n) FORME ; MEDICAMENT (1,1) — Appartenir — (0,n) FAMILLE
• DOSSIER (1,1) — Concerner — (0,1) CONSULTATION ; DOSSIER (1,1) — Déposer — (0,n) MUTUELLE

3. Modèle logique (relationnel)

COOPERATIVE(NumCoop, NomCoop, Adresse)
MEMBRE(NumMembre, Nom, Prenom, CIN, DateNaiss, NumAffiliation, #NumCoop)
SPECIALITE(CodeSpec, LibelleSpec)
MEDECIN(NumMedecin, Nom, Adresse, Tel, #CodeSpec)
CONSULTATION(NumConsult, DateConsult, PrixConsult, #NumMembre, #NumMedecin)
ORDONNANCE(NumOrd, DateOrd, #NumConsult)
FORME(CodeForme, LibelleForme)
FAMILLE(CodeFamille, LibelleFamille)
MEDICAMENT(CodeMed, NomMed, PrixUnitaire, #CodeForme, #CodeFamille)
LIGNE_ORDONNANCE(#NumOrd, #CodeMed, Posologie, Quantite)
MUTUELLE(CodeMut, NomMut, TauxRemb)
DOSSIER(NumDossier, DateDepot, MontantTotal, MontantRembourse, DateRemb, #NumConsult, #CodeMut)

4. Modèle conceptuel des traitements (MCT)

5. Grandes lignes de la réalisation

• Formes de saisie : formulaires écran avec listes déroulantes (choisir le médecin, le médicament dans une liste plutôt que le saisir) ; sous-formulaire pour les lignes d'ordonnance. Exemple : saisie d'une consultation avec choix du membre par son numéro.
• Informations à calculer : montant de l'ordonnance = Σ (quantité × prix unitaire) ; montant remboursé = (prix consultation + montant ordonnance) × taux de la mutuelle ; délai de remboursement = DateRemb − DateDepot.
• Conditions de validité : prix > 0 ; quantité entière ≥ 1 ; DateRemb ≥ DateDepot ; DateConsult ≤ date du jour ; montant remboursé ≤ montant total ; clés étrangères existantes (intégrité référentielle).
• Interrogation (exemples SQL) :

  -- Total remboursé par membre
  SELECT M.NumMembre, M.Nom, SUM(D.MontantRembourse) AS TotalRemb
  FROM MEMBRE M JOIN CONSULTATION C ON C.NumMembre = M.NumMembre
       JOIN DOSSIER D ON D.NumConsult = C.NumConsult
  GROUP BY M.NumMembre, M.Nom;
  
  -- Antibiotiques les plus prescrits
  SELECT MD.NomMed, SUM(L.Quantite) AS Qte
  FROM LIGNE_ORDONNANCE L JOIN MEDICAMENT MD ON MD.CodeMed = L.CodeMed
       JOIN FAMILLE F ON F.CodeFamille = MD.CodeFamille
  WHERE F.LibelleFamille = 'Antibiotiques'
  GROUP BY MD.NomMed ORDER BY Qte DESC;

• Formulaires à établir : fiche membre, fiche médecin, consultation + ordonnance (formulaire/sous-formulaire), dépôt de dossier, suivi des remboursements.
• États de sortie : bordereau de dépôt à la mutuelle ; relevé des remboursements par membre et par période ; statistiques par spécialité ou par famille de médicaments ; liste des dossiers en attente au-delà du délai.
• Distribution de l'application : base centralisée sur un serveur (SGBD client/serveur) avec postes clients en réseau local, ou application web accessible par navigateur ; fourniture d'un exécutable/installateur, d'un manuel utilisateur et d'une formation.
• Sécurité : authentification par mot de passe, profils et droits (saisie, consultation, administration) ; sauvegardes régulières ; journalisation des opérations ; contrôles d'intégrité ; antivirus et protection du réseau ; confidentialité des données médicales.

Sujet 2 — La programmation orientée objet

Introduction

La programmation orientée objet (POO) organise le programme autour d'objets qui regroupent des données (attributs) et les traitements qui les manipulent (méthodes), au lieu de séparer les données et les procédures comme en programmation modulaire/procédurale.

I. Concepts fondamentaux

• Classe : modèle (type) définissant attributs et méthodes. Objet (instance) : exemplaire concret d'une classe, avec un état propre.
• Encapsulation : les données sont cachées (privées) et accessibles uniquement par des méthodes publiques (accesseurs) ; on protège la cohérence de l'objet.
• Constructeur / destructeur : méthodes d'initialisation et de libération de l'objet.
• Héritage : une classe dérivée reprend attributs et méthodes d'une classe de base et les spécialise (relation « est un »).
• Polymorphisme : une même méthode appelée sur des objets de classes différentes produit un comportement adapté (redéfinition / liaison dynamique) ; surcharge : plusieurs méthodes de même nom avec des paramètres différents.
• Abstraction : classes abstraites et interfaces définissant un contrat sans implémentation complète.
• Messages : les objets communiquent en appelant les méthodes les uns des autres ; relations d'association, d'agrégation et de composition.

II. Exemple

abstract class Animal {
    private String identifiant;          // encapsulation
    protected double poids;
    Animal(String id, double p) { identifiant = id; poids = p; }
    String getIdentifiant() { return identifiant; }
    abstract double rationJournaliere(); // abstraction
}
class VacheLaitiere extends Animal {     // héritage
    double productionLait;
    VacheLaitiere(String id, double p, double lait) { super(id, p); productionLait = lait; }
    double rationJournaliere() { return 0.02 * poids + 0.4 * productionLait; }
}
class Ovin extends Animal {
    Ovin(String id, double p) { super(id, p); }
    double rationJournaliere() { return 0.03 * poids; }
}
// Polymorphisme : for (Animal a : troupeau) total += a.rationJournaliere();

Les coefficients de la ration sont fictifs : seul le mécanisme compte. La boucle traite tous les animaux sans connaître leur type exact.

III. Avantages par rapport à la programmation modulaire

• Réutilisation : l'héritage évite de réécrire le code commun ; bibliothèques de classes.
• Maintenance et évolutivité : ajouter un nouveau type (classe Caprin) ne modifie pas le code existant.
• Fiabilité : l'encapsulation empêche les modifications incontrôlées des données (en modulaire, des variables globales peuvent être modifiées partout).
• Modélisation proche du réel : les objets correspondent aux entités du domaine, ce qui facilite le dialogue avec les utilisateurs (UML).
• Travail en équipe : classes indépendantes développées et testées séparément.

Limites à mentionner : conception initiale plus exigeante, risque de hiérarchies d'héritage trop profondes, surcoût pour de petits programmes.

Conclusion

La POO prolonge la programmation modulaire en associant données et traitements ; elle est aujourd'hui dominante (Java, C++, C#, Python) parce qu'elle facilite la réutilisation et la maintenance des grandes applications.