Ce document traite des exceptions en Java, expliquant leur définition, levée et traitement à l'aide des mots-clés 'throw' et 'throws', ainsi que l'utilisation des blocs 'try' et 'catch'. Il aborde également les interfaces graphiques en Java, soulignant la structure des composants et conteneurs, ainsi que la gestion des événements. En outre, le document évoque les flux d'entrée/sortie et la sérialisation des objets, permettant ainsi la persistance et l'échange de données.

1. « Partie3 »
Exceptions
Interfaces graphiques
Flux d’entrée-sortie
Sérialisation
Pr H.LAARAJ
hasLaaraj@gmail.com
http://lewebpedagogique.com/laarajbts 2015/2016
90

2. 11. Les exceptions
méthode() throws XException main() catch XException
91
void methode() throws XException
{
// code qui peut généré XException
}
public static void main()
{
try { methode(); //appel de methode() }
catch(Xexception e) { …}
}

3. 11.1 définition:
Une exception est un signal qui se déclenche en cas de problème qui
conduit le plus souvent à l'arrêt du programme. Les exceptions permettent
de gérer les cas d'erreur et de rétablir une situation stable (ce qui veut dire,
dans certains cas, quitter ou bien continuer à exécuter l'application
proprement).
La gestion des exceptions se décompose en deux phases :
 La levée d'exceptions: throw , throws
 Le traitement d'exceptions: try ,catch
En Java
 une exception est représentée par une classe
 la superclasse qui gère les exceptions s'appelle Exception
92

4. 11.2 Traitement d'exception
Le traitement des exceptions se fait à l'aide de la séquence d'instructions
try...catch...finally.
 L'instruction try indique qu'une instruction (ou plus généralement un bloc
d'instructions) susceptible de lever des exceptions.
 L'instruction catch indique le traitement pour un type particulier
d'exceptions. Il peut y avoir plusieurs instructions catch pour une même
instruction try.
 L'instruction finally, qui est optionnelle, sert à définir un bloc de code à
exécuter dans tous les cas, exception levée ou non.
Exemple 11.2 : soit un code qui génère une exception lorsque p est null
List<Personne> col = new ArrayList<Personne>();
col.add(new Personne ("a","adil",15));
col.add(null);
col.add(new Personne ("b","hoda",25);
for(Personne p : col) p.afficher();
Modifier le code de façon que le système affiche un message d’erreur et
continue à exécuter jusqu' à la fin de programme?
93

5. Solution de l’exemple 11.2
List<Personne> col = new ArrayList<Personne>();
col.add(new Personne ("a","adil",15));
col.add(null);
col.add(new Personne ("b","hoda",25));
for(Personne p : col) {
try{
p.afficher();
}
catch(NullPointerException e){
System.out.println("Erreur: "+e.getMessage());
}
} // fin for
System.out.println("fin"); /* s’il n y pas try et catch le système n’arrive
pas à exécuter cette instruction s’il génère une exception */
94

6. 11.3 Levée d'exception
throws: ce mot clé permet de signaler à la JVM qu'une méthode est potentiellement
dangereux et qu'il faut utiliser un bloc try{…}catch{…}.
throws est suivi du nom de la classe qui va gérer l'exception.
Exemple:
public void maMethode(…) throws IOException {
//code de la methode
}
L’exception IOException est également envoyée à la méthode appelante grâce à
l'instruction throws.
95
throw:
celui-ci permet tout simplement de lever une exception manuellement en instanciant
un objet de type Exception (ou un objet hérité).
Exemple:
if (k<0)
throw new NombreNegatifException();

7. 11.4 Les exceptions personnalisées
Creation d’exception personnalisée:
Pour créer son propre type d'exception, il faut écrire une classe héritant de la
classe Exception.
Exemple 11.4:
On suppose que le champ âge est déclaré private
1. Créer une exception personnalisée qu'on appellera
AgeNonValideException qu'on lèvera si l'utilisateur de notre programme
entre un âge <0 ou > 150
2. Ajouter la méthode setAge(int a) qui lève l’exception si âge est non
valide
3. modifier le code principale suivant à fin qu’il traite l’exception
AgeNonValideException
Personne p= new Personne ("fahmi","adil",22);
p.setAge(235);
p.afficher();
96

8. Solution de l’exemple 11.4
//3. classe Principale
public static void main(String[] args) {
Personne p= new Personne ("fahmi","adil",22);
try {
p.setAge(235);
} catch (AgeNonValideException e) {
System.out.println(e); //e<=> e.toString()
}
p.afficher();
}
97
//1.
class AgeNonValideException extends Exception {
@Override
public String toString() {
return "Exception, age non valide";
}
}
//2. Dans la classe personne on ajoute:
void setAge(int age)throws AgeNonValideException
{
if(age<0||age>150)
throw new AgeNonValideException();
else
this.age = age;
}

9. 11.5 Exercice
1. Ecrire la class Sécurité qui avoir 2 attributs(login , pwd) et une
méthode void saisir() qui permet de saisir un login et un password?
2. Implémenter les exceptions suivantes:
 WrongLoginException qui se produit lorsque l'utilisateur saisit un
login inexistant
 WrongPwdException lorsque le mot de passe est erroné
3. Écrire un programme principale qui demande en boucle un nom
d'utilisateur (login) et un mot de passe (pwd) jusqu'à recevoir un
login/pwd correct?
98

10. 12 Une interface graphique
99

11. 12.1 Définition:
• Une interface graphique en Java est un assemblage
conteneurs (Container) et de composants
(Component).
• Un composant est une partie "visible" de l'interface
utilisateur Java.
 Exemple : les boutons, les zones de textes ou de dessin, etc.
• Un conteneur est un espace dans lequel on peut
positionner plusieurs composants.
 La classe Container est elle-même une sous-classe de la classe
Component
 Par exemple les fenêtres, les applets, etc.
100

12. 12.2 Le gestionnaire de disposition
• A chaque conteneur est associé un gestionnaire de
présentation (layout manager)
• Le gestionnaire de disposition gère le positionnement et
le (re)dimensionnement des composants d’un
conteneur.
• Les principaux gestionnaires de disposition de l'AWT sont :
FlowLayout, BorderLayout, GridLayout, CardLayout,
GridBagLayout
101

13. 12.3 Exemple :
102
Conteneur
(Container)
Composantes
Créer l’interface graphique suivante?

14. Solution de l’exemple 12.3
b.setBounds(X,Y+100, L, H);
Container c=this.getContentPane();
c.setLayout(null);
c.add(la); c.add(t); c.add(b);
setSize(L*2, L*2);
}
}
//la classe principale
public static void main(String[] args) {
Forme f=new Forme("bts dsi ");
f.setVisible(true);
// ou: new Forme("bts dsi ").setVisible(true);
}
103
public class Forme extends JFrame {
private final static int X=70;
private final static int Y=30;
private final static int H=30;
private final static int L=150;
JLabel la;
JTextField t;
JButton b;
public Forme(String string ) {
super(string);
la =new JLabel("entrer le code");
la.setBounds(X,Y, L, H);
t=new JTextField (7);
t.setBounds(X,Y+50, L, H);
b=new JButton("ok");

15. 12.4 Gestion des évènements
104
ECOUTEUR

16. 12.4.1 modèle Emetteur/Récepteur
Un composant déclenche un évènement, envoyé sous
forme d’un objet e à un ou plusieurs objet(s) écouteur(s)
(listeners) qui se sont auparavant « enregistrés » auprès du
composant.
Ces écouteurs réagissent alors à l’évènement.
105

17. 12.4.2 Ecouteurs d’évènements
Tous les composants AWT et Swing sont des sources d’évènements possibles.
Chaque type de composant propose des méthodes permettant à un objet
écouteur de s’enregistrer auprès de lui.
Forme générale : composant.add…Listener(ecouteur)
Avec ecouteur est l’objet créer par une classe qui implémente l’interface
…Listener (ActionListener, MouseListener, keyListener,…)
Exemple pour la classe JButton b:
//classe interne
class Ecouteur implements ActionListener{ void
actionPerformed(ActionEvent e) {
// traitement lorsqu’on click sur bouton b }}
//affecter ecouteur au bouton b
b.addActionListener(new Ecouteur());
) ;
106

18. 12.4.3 Exemple
107
Créer l’interface au-dessus avec:
Bouton ajouter qui permet d’ajouter le texte saisi dans JTextField
Bouton supprimer qui permet de supprimer le texte sélectionné dans JList
JTextField
JList
JButton

19. Solution de l’exemple 12.4.3
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
ba = new JButton("ajouter");
bc = new JButton("supprimer");
}
final void ajoutComposantes(){
setLayout(null);
t.setBounds(X, Y, L, H);
l.setBounds(X, Y+40, L, H*3);
ba.setBounds(X, Y+160, 80, H);
bc.setBounds(X+100, Y+160, 100, H);
add(t); // le conteneur dans ce cas est cette classe Forme
add(l);
add(ba);
add(bc);
}
… dans la suite on utilise deux méthodes
108
public class Forme extends JFrame {
Vector<String> v;
JTextField t; JList l;
JButton ba; JButton bc;
private static final int X=5;
private static final int Y=5;
private static final int L=200;
private static final int H=30;
private void initialiserComposantes() {
v=new Vector<>();
setSize(L+40,L+40);
t=new JTextField();
l=new JList();
l.setBackground(Color.pink);

20. Solution de l’exemple 12.4.3(suite 1)
bc.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent ae) {
v.remove(l.getSelectedValue());
l.setListData(v);
}
});
} // fin du constructeur Forme()
} // fin de la classe Forme
//la classe principale
public static void main(String[] args) {
new Forme().setVisible(true);
}
109
Forme(){
initialiserComposantes();
ajoutComposantes();
/* on utilise la méthode addActionListener qui
reçoit comme argument un objet instancié par
une classe anonyme qui implémente l’interface
ActionListener
bouton.addActionListener(objet)*/
ba.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent ae){
v.add(t.getText());
l.setListData(v);
t.setText("");
}
});
1ére méthode : Traitement d’événement par une classe anonyme

21. Solution de l’exemple 12.4.3(suite 2)
ba.addActionListener((ActionEvent ae) -> {
v.remove(l.getSelectedValue());
l.setListData(v);
});
} // fin du constructeur Forme()
} // fin de la classe Forme
//la classe principale
public static void main(String[] args) {
new Forme().setVisible(true);
}
110
Forme(){
initialiserComposantes();
ajoutComposantes();
/* on utilise même méthode addActionListener(arg)
qui reçoit comme argument une expression lambda.
arg =((entrée de actionPerformed) -> {sa code })
*/
ba.addActionListener((ActionEvent ae) -> {
v.add(t.getText());
l.setListData(v);
t.setText("");
});
2ème méthode : Traitement d’événement par l’expression lambda

22. 13 Flux(flots) d’entrée/ sortie
111

23. 13.1 Définition:
Flux : tuyaux dans lesquels on envoie ou on lit des séries de
données.
 un flux d’entrée permet de lire des éléments.
 un flux de sortie permet d’écrire des éléments.
En Java, toutes les entrées/sorties sont gérées via des flux
Entrées/sorties standards (clavier/console)
Fichiers
Sockets
 ...
112

24. 13.2 les familles de flux
Il y a deux grandes classes de flux :
 les flux d’éléments binaires, sous-classes de InputStream et OutputStream
 les flux de caractères , sous-classes de Reader et Writer ;
113
Texte variable Objet
Flux de sortie FileWriter
PrintWriter
FileOutputStream
DataOutputStream
FileOutputStream
ObjectOutputStream
Flux d’entrée FileReader
BuffredReader
FileInputStream
DataInputStream
FileInputStream
ObjectInputStream

25. 13.3 Exemple
Ecrire un code java qui permet de :
1. Sauvegarder dans un fichier texte deux lignes
• BTS DSI 1ere année
• BTS DSI 2eme année
2. Lire tous les lignes du fichier crée
114

26. Solution de l’exemple 13.3
/* 2. */
FileReader fr=null;
BufferedReader br=null;
try{
fr = new FileReader("fich.txt");
br = new BufferedReader(fr);
String ligne=null;
while ((ligne=br.readLine())!=null)
System.out.println(ligne);
} catch (Exception e) {e.printStackTrace();}
finally{// fermeture des flux
try{
if(br!=null) br.close();
if(fr!=null) fr.close();
} catch (Exception e) {e.printStackTrace();}
} }
115
1. public static void main(String[] args) {
FileWriter fw=null;
PrintWriter pw=null;
try {
fw=new FileWriter("fich.txt");
pw=new PrintWriter(fw);
pw.println("BTS DSI 1ere annee");
pw.println("BTS DSI 2eme annee");
} catch (IOException e) {e.printStackTrace();}
finally{ //fermeture des flux s’ils ont été ouvert
try {
if(fw!=null) fw.close();
if(pw!=null) pw.close();
} catch (IOException e) {e.printStackTrace();}

27. 13.4 sérialisation
permet de rendre un objet ou un graphe d'objets de la JVM persistant pour
stockage ou échange et vice versa.
Ainsi il pourra être stocké sur un disque dur ou transmis au travers d'un réseau pour
le créer dans une autre JVM.
Tout objet qui doit être sérialisé doit implémenter l’interface Serializable.
116
Flux d’octets Flux d’octets
BD
Réseau
Fichier
sérialisation désérialisation
ObjectOutputStream ObjectInputStream
R
Objets
RAM RAM
Objets

28. 13.5 Exemple
Ecrire un code java qui permet de :
1. Sauvegarder dans un fichier binaire un objet de type
Personne
2. Lire l’objet à partie du fichier crée
117

29. Solution de l’exemple 13.5
finally{ //fermeture de flux s’il a été ouvert
try{ if (oos!=null) oos.close(); }
catch(Exception e){e.printStackTrace();}
}
/* 2.*/ ObjectInputStream ois=null;
try{
ois=new ObjectInputStream
(new FileInputStream("fich"));
Personne pf=(Personne)ois.readObject();
pf.afficher();
}
catch(IOException e){e.printStackTrace();}
finally{
try{ if (ois!=null) ois.close(); }
catch(Exception e){e.printStackTrace();}
}} // fin de main()
118
/*On ne peut pas stocker un objet dans un fichier
s’il n’a pas été sérialisé. Alors on doit modifier
l’entête de la classe Personne par :*/
class Personne implements Serializable{
// les champs + méthode afficher() + …
}
//classe principale
1. public static void main(String[] args) {
Personne p=new Personne("elfid","hassan",54);
ObjectOutputStream oos=null;
try{
oos=new ObjectOutputStream(new
FileOutputStream("fich"));
oos.writeObject(p);
}
catch(Exception e){e.printStackTrace();}