DOSSIER 3 - DOSSIER 3 - JAVA ET IHM JAVA ET

Question 1 :

Les patrons de conception utilisés dans cette architecture sont :

Le patron de conception Composite : Ce patron permet de traiter les objets individuels et les
compositions d'objets de manière uniforme. Dans ce cas, la classe TacheComplexe sera le
composite qui contient des sous-tâches (soit des tâches élémentaires, soit des tâches
complexes). Ainsi, les opérations d'ajout et de suppression de sous-tâches sont gérées de
manière cohérente pour les tâches complexes.

Le patron de conception Strategy : Bien que cela ne soit pas spécifié dans le texte, il est
implicite que la classe Tache (ou ses implémentations) utilise une stratégie pour calculer le
coût total d'une tâche complexe. L'utilisation de ce patron permet de déléguer le calcul du
coût à une stratégie appropriée, ce qui peut être utile si différentes tâches complexes
nécessitent des algorithmes de calcul de coût différents.

La classe TacheElementaire :

public class TacheElementaire implements Tache {

private String nom;
private int cout;

public TacheElementaire(String nom, int cout) {

this.nom = nom;
this.cout = cout;
}

@Override
public String getNom() {
return nom;
}
@Override
public int getCout() {
return cout;
}
}
 Question 2 :

1)
Le principal intérêt de la généricité est d'améliorer la sécurité et la
fiabilité du code en permettant la manipulation de types spécifiques
de manière générique. Voici quelques avantages de la généricité :

a) Sécurité des types : La généricité permet de spécifier le type attendu

pour une collection, une classe ou une méthode, ce qui permet de
détecter les erreurs de type lors de la compilation plutôt qu'à
l'exécution. Cela évite les erreurs de caste (casting) et facilite la
détection précoce des erreurs de programmation.
b) Réutilisabilité : En utilisant des types génériques, les classes et les
méthodes peuvent être réutilisées avec différents types de données,
ce qui permet d'écrire du code plus générique et flexible. Cela évite la
duplication de code pour des types similaires.
c) Code plus lisible et maintenable : L'utilisation de la généricité permet
d'écrire du code plus lisible et compréhensible, car les types utilisés
sont spécifiés de manière claire. Cela facilite également la
maintenance du code, car les modifications ou les ajouts ultérieurs de
types peuvent être gérés plus facilement.
d) Performances : En utilisant des types génériques, il est possible
d'obtenir des performances optimales sans nécessiter de conversions
de types coûteuses, car le code est généré spécifiquement pour
chaque type spécifié lors de l'utilisation.

2)
Le coût de la tâche tA construite selon le listing donné serait de 30. Cela est dû au
fait que tA est une tâche complexe composée de deux sous-tâches élémentaires :
"A1" avec un coût de 10 et "A2" avec un coût de 20. Le coût total de tA est la somme
des coûts de ses sous-tâches, donc 10 + 20 = 30. Ainsi, la ligne de code
System.out.println("Cout de tA = " + tA.getCout()); affichera "Cout de
tA = 30" lors de son exécution.
 3) La classe TacheComplexe :

import java.util.ArrayList;
import java.util.Collection;
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<>();
}

public void ajouter(Tache tache) {

sousTaches.add(tache);
}
public void supprimer(Tache tache) {
sousTaches.remove(tache);
}

@Override
public String getNom() {
return nom;
}

@Override
public int getCout() {
int coutTotal = 0;
for (Tache sousTache : sousTaches) {
coutTotal += sousTache.getCout();
}
return coutTotal;
}

@Override
public Iterator<Tache> iterator() {
return sousTaches.iterator();
}
}
5) TacheComplexeSwing
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class TacheComplexeSwing {

private TacheComplexe tache;
final JFrame fenetre = new JFrame("Nouvelle tâche");
final private JTextField valeurNom = new JTextField(10);
final private JTextField valeurCout = new JTextField(10);
final private JButton boutonAjouter = new JButton("Ajouter");
final private JButton boutonQuitter = new JButton("Quitter");

public TacheComplexeSwing(TacheComplexe tache) {

this.tache = tache;

boutonQuitter.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

fenetre.dispose(); // Ferme la fenêtre
}
});

boutonAjouter.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String nom = valeurNom.getText();
String coutTexte = valeurCout.getText();

try {
int cout = Integer.parseInt(coutTexte);
TacheElementaire sousTache = new TacheElementaire(nom, cout);
tache.ajouter(sousTache);
valeurNom.setText("");
valeurCout.setText("");
valeurNom.setBackground(Color.WHITE);
valeurCout.setBackground(Color.WHITE);
} catch (NumberFormatException ex) {
// Gestion de l'erreur de conversion du coût
valeurCout.setBackground(Color.RED);
}
}
});

Container c = fenetre.getContentPane();
c.setLayout(new BorderLayout());
JPanel informations = new JPanel(new GridLayout(2, 2));
 informations.add(new JLabel("Nom : ", SwingConstants.RIGHT));
informations.add(valeurNom);
informations.add(new JLabel("Coût : ", SwingConstants.RIGHT));
informations.add(valeurCout);
c.add(informations, BorderLayout.CENTER);
JPanel boutons = new JPanel(new FlowLayout());
boutons.add(boutonAjouter);
boutons.add(boutonQuitter);
c.add(boutons, BorderLayout.SOUTH);
fenetre.pack();
fenetre.setVisible(true);
}
}