Examen NFP121
Examen NFP121
Programming, Math, etc. · exam
Voir tous les documents en programmationTous les examens en programmation
Fiche de révisionCorrigé
Rédigée à partir de ce document, puis vérifiée avant publication.
Ce document présente un examen de programmation orientée objet et XML, axé sur la conception et la manipulation de tâches hiérarchiques en Java, ainsi que sur la gestion de fichiers XML. Il évalue les compétences en modélisation, codage Java, utilisation d’interfaces graphiques Swing, génération de fichiers XML avec JDom, et traitement SAX.
Il s’agit d’identifier les patrons de conception utilisés dans l’architecture des tâches, puis d’implémenter la classe TacheElementaire conforme à l’interface Tache.
L’architecture donnée présente une hiérarchie où une tâche est soit élémentaire, soit complexe (composée de sous-tâches). Ce modèle correspond au patron Composite :
Les méthodes ajouter(Tache) et supprimer(Tache) sont définies uniquement sur le composite, ce qui est conforme au patron Composite classique.
Réponse : Le patron Composite est utilisé.
La classe doit implémenter l’interface Tache, fournir un constructeur avec nom et coût, et implémenter les méthodes getNom() et getCout().
public class TacheElementaire implements Tache {
private String nom;
private int cout;
public TacheElementaire(String nom, int cout) {
this.nom = nom;
this.cout = cout;
}
public String getNom() {
return this.nom;
}
public int getCout() {
return this.cout;
}
}
Réponse : La classe TacheElementaire est définie comme ci-dessus.
On étudie la classe TacheComplexe, qui stocke ses sous-tâches dans une Collection générique et implémente Iterable pour permettre leur parcours.
La généricité permet au compilateur d’effectuer un contrôle de type à la compilation, évitant ainsi les erreurs de type au moment de l’exécution.
Réponse : Le principal intérêt est le contrôle de type réalisé par le compilateur.
La tâche tA est créée avec deux sous-tâches élémentaires A1 (coût 10) et A2 (coût 20). Le coût d’une tâche complexe est la somme des coûts de ses sous-tâches.
Donc, coût de tA = 10 + 20 = 30.
Réponse : Le coût de tA est 30.
La classe doit implémenter l’interface Tache et Iterable<Tache>, stocker les sous-tâches dans une Collection<Tache>, et fournir les méthodes ajouter, supprimer, getNom, getCout, et iterator.
import java.util.Collection;
import java.util.ArrayList;
import java.util.Iterator;
public class TacheComplexe implements Tache, Iterable<Tache> {
private String nom;
private Collection<Tache> sousTaches;
public TacheComplexe(String nom) {
this.nom = nom;
this.sousTaches = new ArrayList<Tache>();
}
public void ajouter(Tache tache) {
this.sousTaches.add(tache);
}
public void supprimer(Tache tache) {
this.sousTaches.remove(tache);
}
public String getNom() {
return this.nom;
}
public int getCout() {
int result = 0;
for (Tache t : sousTaches) {
result += t.getCout();
}
return result;
}
public Iterator<Tache> iterator() {
return this.sousTaches.iterator();
}
}
Réponse : La classe TacheComplexe est définie comme ci-dessus.
Il s’agit de dessiner la fenêtre Swing minimale affichée par la classe TacheComplexeSwing, puis de compléter le code pour rendre les boutons Ajouter et Quitter fonctionnels.
La fenêtre contient :
La fenêtre porte le titre "Nouvelle tâche".
Le bouton Quitter doit fermer la fenêtre. Le bouton Ajouter doit :
Code à insérer dans la classe TacheComplexeSwing :
private class ActionAjouter implements ActionListener {
public void actionPerformed(ActionEvent ev) {
try {
String nom = valeurNom.getText();
int cout = Integer.parseInt(valeurCout.getText());
tache.ajouter(new TacheElementaire(nom, cout));
System.out.println("cout total = " + tache.getCout());
valeurCout.setBackground(Color.WHITE); // Remise à blanc si succès
} catch (NumberFormatException e) {
valeurCout.setBackground(Color.RED);
}
}
}
private class ActionQuitter implements ActionListener {
public void actionPerformed(ActionEvent ev) {
System.out.println("Appui sur Quitter...");
fenetre.dispose();
}
}
Réponse : Les classes ActionAjouter et ActionQuitter sont définies comme ci-dessus, rendant les boutons fonctionnels.
On étudie la représentation XML d’une tâche complexe selon une DTD donnée, puis la génération de ce XML avec JDom.
La tâche tA a pour nom "A" et coût 30, avec deux sous-tâches A1 (10) et A2 (20). Le fichier XML (sans l’entête) est :
<tache>
<attribut nom="nom" valeur="A" />
<attribut nom="cout" valeur="30" />
<tache>
<attribut nom="nom" valeur="A2" />
<attribut nom="cout" valeur="20" />
</tache>
<tache>
<attribut nom="nom" valeur="A1" />
<attribut nom="cout" valeur="10" />
</tache>
</tache>
Réponse : Le contenu XML est celui présenté ci-dessus.
La classe utilise JDom pour construire un document XML valide selon la DTD. La méthode printToXML crée la racine <taches>, ajoute l’élément correspondant à la tâche passée, puis écrit le fichier.
La méthode ajouterAttibut ajoute un élément <attribut> avec les attributs nom et valeur.
Les méthodes getElement sont surchargées pour TacheComplexe, TacheElementaire et Tache, construisant récursivement l’arbre XML.
import org.jdom.*;
import org.jdom.output.*;
import java.io.FileWriter;
import java.io.IOException;
public class TacheJDom {
private XMLOutputter sortie = new XMLOutputter(Format.getPrettyFormat());
public void printToXML(Tache t, String nomFichier) throws IOException {
Element racine = new Element("taches");
racine.addContent(this.getElement(t));
Document d = new Document(racine, new DocType("taches", "taches.dtd"));
sortie.output(d, new FileWriter(nomFichier));
}
public Element ajouterAttibut(Element e, String nom, String valeur) {
Element attribut = new Element("attribut");
attribut.setAttribute("nom", nom);
attribut.setAttribute("valeur", valeur);
e.addContent(attribut);
return e;
}
public Element getElement(TacheComplexe tc) {
Element elt = new Element("tache");
this.ajouterAttibut(elt, "nom", tc.getNom());
this.ajouterAttibut(elt, "cout", "" + tc.getCout());
for (Tache t : tc) {
elt.addContent(getElement(t));
}
return elt;
}
public Element getElement(TacheElementaire te) {
Element elt = new Element("tache");
this.ajouterAttibut(elt, "nom", te.getNom());
this.ajouterAttibut(elt, "cout", "" + te.getCout());
return elt;
}
public Element getElement(Tache t) {
if (t instanceof TacheComplexe) {
return getElement((TacheComplexe) t);
} else {
return getElement((TacheElementaire) t);
}
}
}
Réponse : La classe TacheJDom est complétée comme ci-dessus pour générer un fichier XML valide.
Deux solutions sont proposées :
Réponse : Les patrons Visiteur ou méthode abstraite redéfinie sont adaptés pour générer le XML.
Il s’agit d’écrire un gestionnaire SAX qui calcule la profondeur maximale d’imbrication des éléments <tache> dans un fichier XML conforme à la DTD.
Le principe est de compter le nombre d’éléments <tache> ouverts non fermés (niveau courant), et de mémoriser la profondeur maximale atteinte.
Code partiel et complété :
import org.xml.sax.*;
import org.xml.sax.helpers.*;
class ProfondeurMaxHandler extends DefaultHandler {
private int level;
private int max;
public void startDocument() {
this.level = 0;
this.max = 0;
}
public void startElement(String uriEspaceNom, String nom, String nomQualifie, Attributes attributs) throws SAXException {
if (nomQualifie.equals("tache")) {
this.level++;
if (this.level > this.max) {
this.max = this.level;
}
}
}
public void endElement(String uriEspaceNom, String nom, String nomQualifie) throws SAXException {
if (nomQualifie.equals("tache")) {
this.level--;
}
}
public int getProfondeurMax() {
return this.max;
}
}
Appliqué au fichier XML de la tâche tA (profondeur 2), ce gestionnaire retourne 2.
Réponse : Le gestionnaire SAX est défini comme ci-dessus et calcule correctement la profondeur maximale.
Ce sujet récompense une compréhension précise des patrons de conception, notamment Composite et Visiteur, ainsi que la capacité à coder en Java des classes conformes à des interfaces données.
Il valorise également la maîtrise des collections génériques, de l’interface Iterable, et des exceptions en Java.
La partie interface graphique teste la gestion des événements Swing et la validation des saisies utilisateur.
La génération XML avec JDom exige une bonne organisation du code et la récursivité pour refléter la hiérarchie des tâches.
Enfin, la manipulation SAX demande de bien comprendre le cycle de vie des événements XML et la gestion d’un compteur d’imbrication.
Les erreurs fréquentes à éviter sont :
Une rédaction claire, un code propre et des justifications précises sont indispensables pour obtenir la meilleure note.