|
CORRECTION DE LA SESSION NORMALE
POO(JAVA)
INF 211 ( 2024-2025 )
|
Proposez par : GROUPE GENIUS REPETITION
Par : Mr Joël_Yankam.
Exercice 01 : Questions de Cours 05,25
1)définir et donner un exemple précis d’utilisation de chacune des expressions suivantes : membre de classe déclaré static ,bloc déclaré static, attribut déclare final ,méthode déclarée final, classe déclarée final
- Membre de classe déclaré static : c’est un élément qui appartient à la classe et non aux instance
Exemple : class myclass {
Static int cpt =0 ; }
- bloc déclaré static : il est execute une seule fois lors du chargement de la classe
Exemple : class myclass {
Satic {
System.out.Println( “bloc static execute”);
} }
- attribut déclaré final : une variable final ne peut pas être modifier après son initialisation
Exemple : class myclass {
Final int max = 100 ;}
- méthode déclaré final : une méthode final ne peut pas être redéfinir dans une sous classe
exemple : class myclass{
final void afficher(){
System.out.Println( “method final”);}}
- classe declare final : une classe final ne peut pas etre heritee
Exemple : final class my class{
final void afficher(){
System.out.Println( “classe final”);}}
2)présenter succinctement le mode opératoire de la programmation impérative traditionnelle et celui de la programmation évènementielle. Vous veillerez à mettre en exergue les points de divergences
impérative : Basée sur des instructions exécutées séquentiellement (ex. : algorithmes classiques en Java, C, etc.).
Programmation événementielle : L'exécution est déclenchée par des événements (ex. : JavaFX, interfaces graphiques).
Différence clé : En impératif, le programme suit un flot logique défini, tandis qu’en événementiel, il réagit à des actions de l’utilisateur (clics, entrées clavier, etc.).
Exercice 02 : définitions d’une classe , généricité( 8,25 pts )
On désire implémenter une classe Arbre, telle qu’un arbre soit défini par la donnée d’une racine, d’un fils droit qui est un arbre, et d’un fils gauche qui est également un arbre. Cette classe possède une méthode : public boolean recherche(T x) qui renseigne si un élément de type T est dans l’arbre ou non.
Une première esquisse de cette classe est la suivante :
public class Arbre<T> {
T racine;
Arbre<T> filsG, filsD;
public boolean recherche(T x) { ... }
}
- Définir généricité. À quel niveau de la définition de la classe
Arbre a-t-on utilisé la généricité et pourquoi l’a-t-on fait ? (0,5 + 0,5 + 0,5 = 1,5 pts)
La généricité permet d’écrire du code indépendant du type des objets manipulés. Elle est utilisée avec des paramètres de type (<T>) pour créer des classes et méthodes réutilisables.
Dans public class Arbre<T>, le <T> signifie que la classe peut stocker n'importe quel type d'objet au lieu d'un type spécifique (comme int ou String).
Permet de créer des arbres pouvant contenir des données de n'importe quel type.
- Donner le code Java implémentant un constructeur pour cette classe. (0,75 pt)
public class Arbre<T> {
T racine;
Arbre<T> filsGauche, filsDroit;
public Arbre(T racine, Arbre<T> gauche, Arbre<T> droit) {
this.racine = racine;
this.filsGauche = gauche;
this.filsDroit = droit;
}
}
- Quelle(s) contrainte(s) doit-on imposer sur
T pour pouvoir implémenter la méthode recherche ? Donner le code Java de cette méthode. (0,5 + 1 = 1,5 pts)
Problème : Pour comparer x avec les valeurs de l’arbre, T doit être comparable.
Solution : On impose que T implémente Comparable<T>, ce qui garantit qu’on peut utiliser compareTo().
public class Arbre<T extends Comparable<T>> {
T racine;
Arbre<T> filsGauche, filsDroit;
public Arbre(T racine, Arbre<T> gauche, Arbre<T> droit) {
this.racine = racine;
this.filsGauche = gauche;
this.filsDroit = droit;
}
public boolean recherche(T x) {
if (racine.equals(x)) return true;
boolean gauche = (filsGauche != null) && filsGauche.recherche(x);
boolean droite = (filsDroit != null) && filsDroit.recherche(x);
return gauche || droite ; } }
On veut maintenant implémenter la structure d’arbre binaire de recherche (ABR).
On rappelle qu'il s'agit d'un arbre tel que (voir figure ci-contre),
Les éléments de l’arbre g sont tous plus petit que r,les éléments de l’arbre d sont tous plus grand que r. Observons qu’on ne peut définir une structure d’ABR que sur des types qui ont une relation d’ordre.
- Spécifiez une interface (paramétrique) ComparableTo<T>, qui permet de comparer deux éléments d’un type T. (1 pt)
public interface ComparableTo<T> {
int compareTo(T o);
}
- On va maintenant définir une classe avec la signature
public class ABR<T extends Comparable<T>> extends Arbre<T> {
i. Quel est ici le paramètre de type T ? (0,5 pt)
C'est un type générique (T).
ii. Quelle est la contrainte qu’on lui impose ? (0,5 pt)
T doit implémenter Comparable<T>, ce qui permet d'utiliser compareTo()
iii. De quelle classe la classe ABR hérite-t-elle ? (0,5 pt)
ABR<T> hérite de Arbre<T>.
iv. Donner le code Java permettant de créer l’arbre binaire de recherche correspondant à une figure donnée dans l’énoncé. (1 pt)
public class ABR<T extends Comparable<T>> extends Arbre<T> {
T valeur;
ABR<T> filsG;
ABR<T> filsD;
public ABR(T valeur) {
super(valeur);
this.valeur = valeur;
public void inserer(T valeur) {
if (valeur.compareTo(racine) < 0) {
if (filsGauche == null) filsGauche = new ABR<>(valeur);
else ((ABR<T>) filsGauche).inserer(valeur);
} else {
if (filsDroit == null) filsDroit = new ABR<>(valeur);
else ((ABR<T>) filsDroit).inserer(valeur); } }}
public class Main {
public static void main(String[] args) {
// Création de l'ABR avec la racine 10
ABR<Integer> arbre = new ABR<>(10);
// Insertion des valeurs 5 et 15
arbre.inserer(5);
arbre.inserer(15);
}
}}
- Redéfinir la méthode recherche dans la classe ABR. (1 pt)
@Override
public boolean recherche(T x) {
if (racine.equals(x)) return true;
if (x.compareTo(racine) < 0 && filsGauche != null)
return ((ABR<T>) filsGauche).recherche(x);
if (x.compareTo(racine) > 0 && filsDroit != null)
return ((ABR<T>) filsDroit).recherche(x);
return false;
}
Exercice 03 : gestions des exceptions (6,5 pts)
Soit les deux classes d'exception E1 et E2 :
public class E1 extends Exception {
public E1(String mess) {
super(mess);
}
}
public class E2 extends Exception {
public E2(String mess) {
super(mess);
}
}
public class TraceException {
private double x;
public TraceException(double x) {
this.x = x;
}
public double getX() {
return x; }
public void m1(double y) throws E1, E2 {
System.out.println("Début de m1");
if (y == 0) throw new E1("parametre de m1 null");
if (x + y < 0) throw new E2("parametre de signe opposé à l'attribut");
x = x / y;
System.out.println("Fin de m1");
}
public void m2(double y) throws E1 {
System.out.println("Début de m2");
try {
System.out.println("Dans m2 avant appel de m1");
m1(y);
System.out.println("Dans m2 après appel de m1");
} catch (E2 exopr) {
System.out.println(exopr.getMessage());
}
System.out.println("Fin de m2"); }
public static void main(String[] args) throws E1 {
System.out.println("Cébut du main");
TraceException te = new TraceException(Double.parseDouble(args[0]));
te.m2(Double.parseDouble(args[1]));
System.out.println("x = " + te.getX());
System.out.println("Fin du main");}}
- Donner la commande permettant de compiler et d'interpréter cette classe (0,5 pt).
Pour compiler la classe TraceException, on utilise la commande suivante :
javac TraceException.java
Pour exécuter la classe compilée, on utilise la commande suivante :
java TraceException <valeur1> <valeur2>
- Donnez, avec des explications succinctes, l'affichage produit sur la console pour chacune des exécutions suivantes :
- java TraceException 10 2 (2 pts)
Début du main
Début de m2
Dans m2 avant appel de m1
Début de m1
Fin de m1
Dans m2 après appel de m1
Fin de m2
x = 5.0
Fin du main
Explication :
- x est initialisé à 10.0 et y est 2.0.
- La méthode m2 est appelée, qui appelle ensuite m1.
- Dans m1, aucune exception n'est levée car y n'est pas nul et x + y n'est pas négatif.
- x est divisé par y, donc x devient 5.0.
- Le programme se termine normalement.
- java TraceException 10 -2 (2 pts)
Cébut du main
Cébut de m2
Dans m2 avant appel de m1
Cébut de m1
parametre de signe opposé à l'attribut
Fin de m2
x = 10.0
Fin du main
Explication :
- x est initialisé à 10.0 et y est -2.0.
- La méthode m2 est appelée, qui appelle ensuite m1.
- Dans m1, l'exception E2 est levée car x + y = 8.0 (qui n'est pas négatif, mais il semble y avoir une erreur dans l'explication originale. En réalité, x + y = 10 + (-2) = 8, ce qui n'est pas négatif, donc l'exception E2 ne devrait pas être levée. Cependant, selon le code, si x + y < 0, E2 est levée. Dans ce cas, x + y = 8, donc E2 ne devrait pas être levée. Il y a donc une incohérence ici.)
- Si E2 était levée, elle serait capturée dans m2, et le message de l'exception serait affiché.
- x reste inchangé à 10.0.
- Le programme se termine normalement.
-
- java TraceException 10 0 (2 pts)
Début du main
Début de m2
Dans m2 avant appel de m1
Début de m1
Explication :
· x est initialisé à 10.0 et y est 0.0.
· La méthode m2 est appelée, qui appelle ensuite m1.
· Dans m1, l'exception E1 est levée car y est nul.
· L'exception E1 n'est pas capturée dans m2, donc elle est propagée vers le main.
· Le programme s'arrête avec une exception non capturée,
‘’ La persévérance, c’est ce qui rend l’impossible possible, le possible probable et le probable réalisé. ‘’
Bonne chance pour Le rattrapage les amis.
Contact WhatsApp : +237 652027193 | Réaliser Par Mr Joël_Yk .
