Correction détaillée – Examen Java 2H
2025
Exercice 1 : Questions de cours
1. Héritage en Java
L’héritage est un mécanisme permettant à une classe (classe fille) de récupérer
les attributs et méthodes d’une autre classe (classe mère), afin de favoriser la
réutilisation du code et la spécialisation.
Exemple :
1 class Animal {
2 void crier () { System . out . println ( " Animal " ) ; }
3 }
4 class Chien extends Animal {
5 void crier () { System . out . println ( " Wouf " ) ; }
6 }
7 // Utilisation :
8 Animal a = new Chien () ;
9 a . crier () ; // Affiche " Wouf "
2. Différence entre ArrayList et LinkedList
ArrayList : Tableau dynamique, accès rapide par indice, bonne pour l’accès en
lecture. Exemple : liste d’étudiants.
LinkedList : Liste doublement chaînée, insertions/suppressions rapides au début
ou au milieu. Exemple : file d’attente.
3. Deux avantages des interfaces en Java :
— Permettent de définir un contrat que plusieurs classes peuvent implémenter.
— Permettent un héritage multiple de comportements.
4. Exception personnalisée en Java
Une exception personnalisée est une classe créée par l’utilisateur héritant de Excep-
tion (ou RuntimeException) pour signaler une erreur spécifique à l’application.
Exemple :
1 class NoteException extends Exception {
2 public NoteException ( String msg ) { super ( msg ) ; }
3 }
4 // Utilisation
5 throw new NoteException ( " Note invalide ! " ) ;
1
5. Principe du casting en Java
Le casting permet de convertir une variable d’un type à un autre compatible (trans-
typage).
Exemple :
1 double d = 3.14;
2 int n = ( int ) d ; // n prend la valeur 3
6. Mot-clé final
Sur une variable : valeur constante non modifiable.
Sur une méthode : méthode non redéfinissable.
Sur une classe : classe non héritée.
Exemple :
1 final int MAX = 100;
2
Exercice 2 : Correction de code
Erreurs à repérer et corriger :
1. List<Integer> nombres = null ; puis [Link](10);
Problème : La liste est non initialisée, l’appel lève NullPointerException.
Correction :
1 List < Integer > nombres = new ArrayList < >() ;
2. public Personne(String nom) { nom = nom ; }
Problème : n’initialise pas l’attribut, affecte seulement le paramètre local.
Correction :
1 public Personne ( String nom ) { this . nom = nom ; }
3. for(int i = 0 ; i <= [Link] ; i++)
Problème : Dépassement d’indice à i = [Link].
Correction :
1 for ( int i = 0; i < tab . length ; i ++) {
2 System . out . println ( tab [ i ]) ;
3 }
Code corrigé complet :
1 import java . util .*;
2 public class Main {
3 public static void main ( String [] args ) {
4 List < Integer > nombres = new ArrayList < >() ;
5 nombres . add (10) ;
6 nombres . add (20) ;
7
8 System . out . println ( nombres . get (1) ) ;
9
10 Personne p = new Personne ( " Alice " ) ;
11 System . out . println ( p . getNom () ) ;
12
13 int [] tab = {1 , 2 , 3};
14 for ( int i = 0; i < tab . length ; i ++) {
15 System . out . println ( tab [ i ]) ;
16 }
17 }
18 }
19 class Personne {
20 private String nom ;
21 public Personne ( String nom ) { this . nom = nom ; }
22 public String getNom () { return nom ; }
23 }
Explications :
- Une ArrayList doit être initialisée avant utilisation.
- On utilise [Link] pour référencer l’attribut de la classe.
- On boucle jusqu’à < [Link] pour parcourir le tableau.
3
Exercice 3 : Exercice sur le résultat d’un code donné
Code à expliquer :
1 ArrayList < String > noms = new ArrayList < >() ;
2 noms . add ( " Ali " ) ;
3 noms . add ( " Sarah " ) ;
4 noms . add ( " Yasmine " ) ;
5 for ( int i = 0; i < noms . size () ; i ++) {
6 if ( noms . get ( i ) . startsWith ( " A " ) ) {
7 noms . remove ( i ) ;
8 }
9 }
10 System . out . println ( noms ) ;
a) Résultat affiché et explication ligne par ligne :
Après l’exécution, la liste affichée sera [Sarah, Yasmine].
Explication :
— On ajoute "Ali", "Sarah", "Yasmine" à la liste.
— Boucle : i = 0, [Link](0)="Ali" commence par "A", on supprime l’élément
d’indice 0.
— Maintenant, noms=[Sarah, Yasmine], i=0 pointe sur "Sarah".
— i = 1, [Link](1)="Yasmine" (ne commence pas par "A"), rien n’est sup-
primé.
— Affichage : [Sarah, Yasmine]
Problème : Quand on supprime un élément dans une boucle for, tous les éléments
suivants sont décalés. Certains éléments peuvent être "sautés".
b) Avec LinkedList ?
Même résultat, car remove(int index) fonctionne aussi avec LinkedList et les in-
dices sont décalés. Mais sur de grandes listes, la suppression en plein milieu d’une
LinkedList est plus lente qu’avec ArrayList pour l’accès par index.
c) Version correcte pour supprimer tous les noms commençant par "A" :
Il faut parcourir la liste à l’envers ou utiliser un Iterator :
1 for ( int i = noms . size () - 1; i >= 0; i - -) {
2 if ( noms . get ( i ) . startsWith ( " A " ) ) {
3 noms . remove ( i ) ;
4 }
5 }
6 // OU
7 Iterator < String > it = noms . iterator () ;
8 while ( it . hasNext () ) {
9 if ( it . next () . startsWith ( " A " ) ) it . remove () ;
10 }
4
Exercice 4 : Manipulation de ArrayList et LinkedList
a) ArrayList d’entiers :
1 ArrayList < Integer > liste = new ArrayList < >() ;
2 liste . add (2) ; liste . add (4) ; liste . add (6) ; liste . add (8) ; liste . add (10) ;
3 // Remplacer 6 par 12
4 liste . set ( liste . indexOf (6) , 12) ;
5 // Supprimer 4
6 liste . remove ( Integer . valueOf (4) ) ;
7 // Afficher tous les elements
8 for ( Integer n : liste )
9 System . out . println ( n ) ;
Explications : - set(...) modifie la valeur à l’indice donné. - remove([Link](4))
supprime la valeur 4 (et non l’élément à l’indice 4).
b) LinkedList de chaînes :
1 LinkedList < String > liste = new LinkedList < >() ;
2 liste . add ( " one " ) ; liste . add ( " two " ) ; liste . add ( " three " ) ;
3 liste . addFirst ( " zero " ) ;
4 liste . addLast ( " four " ) ;
5 liste . removeFirst () ;
6 for ( String s : liste )
7 System . out . println ( s ) ;
Explications : - addFirst, addLast pour insérer au début/fin. - removeFirst() supprime
"zero".
5
Exercice 5 : Swing, comportement d’un bouton
a) Fenêtre Swing simple :
1 import javax . swing .*;
2 public class MaFenetre {
3 public static void main ( String [] args ) {
4 JFrame fen = new JFrame ( " Bienvenue " ) ;
5 fen . setSize (400 , 200) ;
6 fen . s e t D e f a u l t C l o s e O p e r a t i o n ( JFrame . EXIT_ON_CLOSE ) ;
7 fen . s e t L o c a t i o n R e l a t i v e T o ( null ) ; // Centrer a lecran
8 fen . setVisible ( true ) ;
9 }
10 }
Explications : - setLocationRelativeTo(null) centre la fenêtre.
b) Bouton et gestionnaire d’événement :
1 import javax . swing .*;
2 import java . awt . event .*;
3
4 public class Fenetre {
5 public static void main ( String [] args ) {
6 JFrame fen = new JFrame ( " Ma fenetre " ) ;
7 fen . setSize (300 , 100) ;
8 fen . s e t D e f a u l t C l o s e O p e r a t i o n ( JFrame . EXIT_ON_CLOSE ) ;
9
10 JButton bouton = new JButton ( " Cliquez - moi " ) ;
11 fen . add ( bouton ) ; // Ajout du bouton
12
13 bouton . addAct ionListe ner ( new ActionListener () {
14 public void actionPerformed ( ActionEvent e ) {
15 JOptionPane . sh owMessag eDialog ( fen , " Bonjour " ) ;
16 }
17 }) ;
18
19 fen . setVisible ( true ) ;
20 }
21 }
Explications : - addActionListener définit le comportement du clic. - [Link]
affiche "Bonjour" dans une boîte de dialogue.