[Java][Débutant] setDefaultCloseOperation vs. la gestion des événements sur les JFrame

[Niveau Débutant][Pour les étudiants (ou personnes) qui prennent leurs premiers pas en Java].

La première chose que nous constatons après la création de notre toute première JFrame en Java est la continuation de l'exécution après la fermeture de l'unique fenêtre et même après la fin de la méthode "main". En effet, en créant une JFrame, nous créons un Thread séparé du Thread principal. En fermant la fenêtre, nous la détruisons mais pas le Thread qui l'a exécutée. Ainsi, il faut préciser à la JFrame qu'il faut quitter l'application lors de sa fermeture.

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class ExempleJFrame extends JFrame {
 
 public ExempleJFrame(){
  setTitle("Exemple");
  setSize(300, 200);
  
  JButton bouton = new JButton("Afficher");
  bouton.addActionListener(new ActionListener(){
   public void actionPerformed(ActionEvent e){
    System.out.println("Thread de la JFrame : " + Thread.currentThread().getName());
   }
  });
  
  getContentPane().setLayout(null);
  bouton.setBounds(100, 85, 100, 25);
  getContentPane().add(bouton);
  
  
 }
 
 public static void main (String args[]) {
  
  (new ExempleJFrame()).setVisible(true);
  System.out.println("Thread principal (méthode main) : " + Thread.currentThread().getName());
  
 }
}

La méthode la plus simple pour cela est l'utilisation de la méthode setDefaultCloseOperation(). Cette méthode est un bon exemple sur l’appellation des méthode suivie dans la JDK et confirme la réputation du Java sur cet axe par rapport à d'autres langages de programmation.

setDefaultCloseOperation() prend un entier qui précise l'action à prendre lors de la fermeture de la fenêtre. Les options disponibles sont :

• DO_NOTHING_ON_CLOSE : ne rien faire,
• HIDE_ON_CLOSE : chacher la fenêtre,
• DISPOSE_ON_CLOSE : détruire la fenêtre,
• EXIT_ON_CLOSE : quitter l'application.

Ces constants sont définies dans la classe WindowConstants et elles sont dupliquées (pour des raisons de simplification) dans la classe JFrame. ET là encore, le même principe d'une appellation détaillée est respecté.

On ajoute une seule ligne au code précédent :

setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

Maintenant, l'application rend la main au système après sa fermeture; il n'est plus nécessaire de forcer l'arrêt de l'application par la commande arrêt dans les EDI (un bouton rouge) ou bien Ctrl+C à partir de la ligne de commande.

Java offre aussi la possibilité de personnaliser l'action à prendre lors de la fermeture de la JFrame. Il est aussi possible de détecter tout sorte d'événements sur la fenêtre (modification de la taille, réduction, etc.). Cela est garanti par l'utilisation d'un écouteur pour la fenêtre : WindowListener.

Cet écouteur était l'unique méthode pour définir les actions à prendre lors de la fermeture dans AWT. setDefaultCloseOperation() n'a été introduite que plus tard avec Swing.

WindowListener est, comme tout autre écouteur,  une interface qui définit les méthodes de réception des événement. Et si ActionListener ne propose qu'une seule méthode (actionPerformed) parce qu'il n'écoute qu'un seul événement (le clique), WindowListener de son côté définit sept (07) fonctions. Son code source (officiel mais sans Javadoc) :

package java.awt.event; 
 
import java.util.EventListener; 
 
public interface WindowListener extends EventListener { 
 
    public void windowOpened(WindowEvent e); 
 
    public void windowClosing(WindowEvent e); 
 
    public void windowClosed(WindowEvent e); 
  
    public void windowIconified(WindowEvent e); 
  
    public void windowDeiconified(WindowEvent e); 
 
    public void windowActivated(WindowEvent e); 
 
    public void windowDeactivated(WindowEvent e); 

} 

Vous pouvez lire le code complet avec les commentaires Javadoc :

WindwListener source code

Ainsi, pour définir l'action à exécuter au moment de la fermeture, il faut implémenter les sept méthodes, laisser toutes les méthodes vides et remplir la méthode windowClosing().

Ainsi, le code de notre fenêtre devient :

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class ExempleJFrame extends JFrame {
 
 public ExempleJFrame(){
  setTitle("Exemple");
  setSize(300, 200);
  
  addWindowListener(new MonWindowListener());
 }
 
 public static void main (String args[]) {
  (new ExempleJFrame()).setVisible(true);
 }
}

class MonWindowListener implements WindowListener {
 
    public void windowOpened(WindowEvent e){} 
 
    public void windowClosing(WindowEvent e){
  System.out.println("La fenêtre a été fermée");
  System.exit(0);
 } 
 
    public void windowClosed(WindowEvent e){}
  
    public void windowIconified(WindowEvent e){} 
  
    public void windowDeiconified(WindowEvent e){} 
 
    public void windowActivated(WindowEvent e){}
 
    public void windowDeactivated(WindowEvent e){} 

}

Avant la fermeture

Après la fermeture, l'application rend la main au système
( avec le code 0 passé comme paramètre à la fonction System.exit(0) )

Pour simplifier l'utilisation, une autre classe a été introduite, c'est la classe WindowAdapter. Cette classe ne fait rein de particulier; elle implémente toutes les méthodes des differentes interface liées aux JFrame (et Frame) mais avec des corps de méthodes vides. Son code (sans les Javadoc) :

public abstract class WindowAdapter 
    implements WindowListener, WindowStateListener, WindowFocusListener 
{ 
    public void windowOpened(WindowEvent e) {} 
 
    public void windowClosing(WindowEvent e) {} 
 
    public void windowClosed(WindowEvent e) {} 
 
    public void windowIconified(WindowEvent e) {} 

    public void windowDeiconified(WindowEvent e) {} 
 
    public void windowActivated(WindowEvent e) {} 

    public void windowDeactivated(WindowEvent e) {} 
 
    public void windowStateChanged(WindowEvent e) {} 
 
    public void windowGainedFocus(WindowEvent e) {} 

    public void windowLostFocus(WindowEvent e) {} 
} 

Son code source complet :

WindowAdapter source code

Ainsi, le code de la fenêtre devient (avec une exécution identique) :

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class ExempleJFrame extends JFrame {
 
 public ExempleJFrame(){
  setTitle("Exemple");
  setSize(300, 200);
  
  addWindowListener(new MonWindowAdapter());
 }
 
 public static void main (String args[]) {
  (new ExempleJFrame()).setVisible(true);
 }
}

class MonWindowAdapter extends WindowAdapter {

 @Override
 public void windowClosing(WindowEvent e){
  System.out.println("La fenêtre a été fermée");
  System.exit(0);
 } 

}

L'utilisation des modèles associés aux composants Swing : JList comme exemple

Contrairement aux composants AWT, les composants Swing sépare la représentation (Vue) des données (Modèle) dans une approche très similaire à l'approche (MVC). Cette série vise à mettre l'accent sur séparation et démontrer quelques possibilités offertes par l'hiérarchie des classes Java pour les composants Swing.

La série se compose de quatre (04) articles :

• JList (1) : un premier exemple simple,
• JList (2) : Exemple avec écouteur (Listener) sur la liste elle-même,
• JList (3) : utilisation d'un écouteur (Listener) sur le modèle,
• JList (4) : exemple d'un ListModel minimal.

Bonne lecture.

JList (4) : exemple d'un ListModel minimal

Ce code démontre l'utilisation de la classe AbstractListModel (ou même l'interface ListModel) pour implémenter un modèle personnalisé pour la JList.

Les trois exemples précédents (1, 2 et 3) se basaient sur l'utilisation de DefaultListModel. Cette dernière classe est une extension de la classe AbstractListModel qui utilise un Vector pour stocker le contenu de la liste. Il est possible de construire un modèle de données qui stocke le contenu dans une structure personnalisée.

ListModel

AbstractListModel

DefaultListModel

Le problème avec cette approche est la duplication du référence. Les objets contenants les données seront doublement référencés. Ainsi, il est possible dans des cas particulier de définir un modèle qui ne stocke et qui ne garde aucune référence. Il va déléguer ces opérations à une structure déjà disponible dans l'application.

Ce cas est un cas extrême et est présenté ici juste pour donner exemple sur les possibilités obtenues si on opte pour l'utilisation de AbstractListModel au lieu de DefaultListModel.

La classe de donnée utilisée dans cet exemple est une classe très simple qui définit trois attributs (id, nom, prénom) et qui offre une méthode toString pour permettre l'affichage. Une petite méthode "static" est ajoutée pour simuler une source de données externe.

class Donnee {
  
 int id;
 String nom;
 String prenom;
 
 public Donnee(int id, String nom, String prenom){
  this.id = id;
  this.nom = nom;
  this.prenom = prenom;
 }
 
 public int getId(){ return id; }
 public String getNom(){ return nom; }
 public String getPrenom(){ return prenom; }
 
 public String toString(){
  return "(" + id + ") " + nom + " " + prenom;
 }
 
 public static List<Donnee> creerDonnees(){
  ...
 }
 
}

Les données sont exposées, par la suite, dans une liste "static" accessible pour tout le monde (comme j'ai précisé, c'est un cas extrême pour montrer les fonctionnalités possibles).

 public static List<Donnee> DONNEES = Donnee.creerDonnees();

Le modèle développé va déléguer ses fonctionnalités à cette liste

class MonModele extends AbstractListModel<Donnee> {
 
 public int getSize(){
  return ExempleSimpleListModel.DONNEES.size();
 }
 
 public Donnee getElementAt(int indice){
  return ExempleSimpleListModel.DONNEES.get(indice);
 } 
}

Le code complet sera :

import javax.swing.*;
import java.awt.event.*;
import javax.swing.event.*;
import java.util.*;

public class ExempleSimpleListModel {
 
 public static List<Donnee> DONNEES = Donnee.creerDonnees();
 
 public static void main (String args[]) {
  
  (new MaFrame()).setVisible(true);
  
 }
}

class Donnee {
  
 int id;
 String nom;
 String prenom;
 
 public Donnee(int id, String nom, String prenom){
  this.id = id;
  this.nom = nom;
  this.prenom = prenom;
 }
 
 public int getId(){ return id; }
 public String getNom(){ return nom; }
 public String getPrenom(){ return prenom; }
 
 public String toString(){
  return "(" + id + ") " + nom + " " + prenom;
 }
 
 public static List<Donnee> creerDonnees(){
  List<Donnee> liste = new ArrayList<>();
  liste.add(new Donnee(1, "Wilhelm", "Conrad Röntgen"));
  liste.add(new Donnee(2, "Hendrik", "Lorentz"));
  liste.add(new Donnee(3, "Pieter", "Zeeman"));
  liste.add(new Donnee(4, "Antoine Henri", "Becquerel"));
  liste.add(new Donnee(5, "Piere", "Curie"));
  liste.add(new Donnee(6, "Marie", "Curie"));
  return liste;
 }
 
}

class MaFrame extends JFrame {
 
 JList liste;
 MonModele modele;
 
 public MaFrame(){
  
  setTitle("Exemple JList");
  setSize(250, 400);
  setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  
  modele = new MonModele();
  liste = new JList(modele);
  
  getContentPane().add(new JScrollPane(liste));
  
 }
  
}

class MonModele extends AbstractListModel<Donnee> {
 
 public int getSize(){
  return ExempleSimpleListModel.DONNEES.size();
 }
 
 public Donnee getElementAt(int indice){
  return ExempleSimpleListModel.DONNEES.get(indice);
 } 
}

Résultat :

JList (3) : utilisation d'un écouteur (Listener) sur le modèle

Après la présentation d'un premier exemple simple (ici) qui montre la séparation entre la Vue et le Modèle dans les composants Swing et d'un deuxième exemple (ici) qui montre l'utilisation d'un Listener "logique" qui récupère les actions de l'utilisateur, cet article vise à montrer l'utilisation d'un Listener sur le modèle, c'est-à-dire, détecter qu'un changement a eu lieu dans le modèle de donnée.

Malgré qu'un tel écouteur peut être utilisé pour détecter des changements effectués par l'utilisateur, le plus intéressant est de l'utiliser pour détecter des changements appliqués par d'autres programmes ou bien d'autres threads.

Ainsi, pour cet article, deux classes seront nécessaires :

• La fenêtre qui contiendra la liste et son modèle. Pour simplifier l'exemple, le modèle sera exposé via un simple getter.
• Un "autre programme" qui simule une source externe du changement effectué sur le modèle de la liste.

L'écouteur sur un modèle de données ne cherche pas à détecter des actions de l'utilisateur. Mais, il se concentre sur les changements possibles des données. Ainsi, l'écouteur (Listener) ListDataListener propose trois méthodes :

• intervalAdded
• intervalRemoved
• contentsChanged

Les deux premières permet de récupérer les événements simples, le troisième sert à récupérer des changements du contenu du modèle.

ListDataListener (JDK 7)

Les trois méthodes reçoivent le même objet événement : ListDataEvent

ListDataEvent

Si ce dernier ne cache pas les données changées, il garde les positions (début/fin) des intervalles affectées par le changement. Par la suite, il est possible de récupérer les données à partir du modèle lui-même.

Pour pouvoir utiliser directement ces fonctionnalités, il faut faire appel au moins à la classe AbstractListModel, d'ailleurs, c'est la valeur ajoutée principale de cette classe par rapport à l'interface de base ListModel. Autrement, tous les mécanismes internes doivent être implémentées (chose qui n'est pas vraiment difficile après tout).

ListModel

AbstractListModel

Revenons à notre exemple. Il se compose de trois classes :

• Une classe qui simule un programme externe qui change les données. Elle ajoute une donnée à partir d'une position aléatoire d'un tableau qui contient "quelques données".
• Une fenêtre qui continent la liste et qui expose le modèle de la liste. Cette classe constitue aussi l'écouteur ListDtaListener. en recevant une nouvelle valeur, le texte d'une JLabel est mis à jour.
• La classe qui contient le main crée une instance de chaque classe et les passe à deux thread séparés. Pour une meilleure visibilité, l'ajout des valeurs aléatoires s'effectue à des intervalles de 2 seconds. 

Ainsi, le code essentiel de la première classe :

class MonDeuxiemeProgramme {
 
 MaFrame frameAttachee;
 String[] quelquesDonnees = ...;

 public MonDeuxiemeProgramme(MaFrame frame){
  frameAttachee = frame;
 }
 
 public void ajouterElementAleatoire(){
  Random r = new Random();
  int valeur = r.nextInt(26);
  
  frameAttachee.getModele().addElement(quelquesDonnees[valeur]);
 }
 
}

Le code essentiel de la deuxième classe :

class MaFrame extends JFrame implements ListDataListener {

 JList liste;
 DefaultListModel modele;
 
 ...
 
 public MaFrame(){
  
  setTitle("Exemple JList");
  setSize(800, 400);
  setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  
  modele = new DefaultListModel();
  modele.addListDataListener(this);
  liste = new JList(modele);
  
  creerInterface();
  
 }
 
 public void creerInterface(){
  ...
 }
 
 public void intervalAdded(ListDataEvent e){
  lblMessage.setText("Ajout à la position " + e.getIndex0() + " (" + modele.get(e.getIndex0()) + ")");
 }
 
 public DefaultListModel getModele(){
  return modele;
 }
 
 public void intervalRemoved(ListDataEvent e){}
 
 public void contentsChanged(ListDataEvent e){}

} 

Le code complet :

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.event.*;
import java.util.*;

public class ExempleEvenementModelJList {
 
 public static void main (String args[]) {
  
  MaFrame frame = new MaFrame();
  MonDeuxiemeProgramme autre = new MonDeuxiemeProgramme(frame);
  
  Thread t1 = new Thread(new Runnable(){
   
   public void run(){
    frame.setVisible(true);
   }
   
  });
  
  Thread t2 = new Thread(new Runnable(){
   
   public void run(){
    while(true){
     try{
      Thread.sleep(2000);
      autre.ajouterElementAleatoire();
     }catch(Exception e){}
    }
   }
   
  });
  
  t1.start();
  t2.start();
  
 }
}

class MaFrame extends JFrame implements ListDataListener {

 JList liste;
 JScrollPane scroll;
 DefaultListModel modele;
 
 JLabel lblMessage;
 
 JPanel pnlDroite;
 JPanel pnlGauche;
 
 public MaFrame(){
  
  setTitle("Exemple JList");
  setSize(800, 400);
  setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  
  modele = new DefaultListModel();
  modele.addListDataListener(this);
  liste = new JList(modele);
  
  creerInterface();
  
 }
 
 public void creerInterface(){
  
  lblMessage = new JLabel("Pas d'élément pour le moment");
  lblMessage.setBounds(20, 20, 450, 30);
  
  pnlDroite = new JPanel();
  pnlDroite.setLayout(null);
  pnlDroite.add(lblMessage);
  pnlDroite.setPreferredSize(new Dimension(480, 360));
  
  scroll = new JScrollPane(liste);
  scroll.setBounds(0, 0, 250, 360);
  
  pnlGauche = new JPanel();
  pnlGauche.setLayout(null);
  pnlGauche.add(scroll);
  pnlGauche.setPreferredSize(new Dimension(280, 360));
  
  getContentPane().setLayout(new FlowLayout());
  getContentPane().add(pnlGauche);
  getContentPane().add(pnlDroite);
  
 }
 
 public void intervalAdded(ListDataEvent e){
  lblMessage.setText("Ajout à la position " + e.getIndex0() + " (" + modele.get(e.getIndex0()) + ")");
 }
 
 public DefaultListModel getModele(){
  return modele;
 }
 
 public void intervalRemoved(ListDataEvent e){}
 
 public void contentsChanged(ListDataEvent e){}

} 

class MonDeuxiemeProgramme {
 
 MaFrame frameAttachee;
 String[] quelquesDonnees = new String[]{"Alfa",
  "Bravo", "Charlie", "Delta", "Echo", "Foxtrot", "Golf",
  "Hotel", "India", "Juliett", "Kilo", "Lima", "Mike",
  "November", "Oscar", "Papa", "Quebec", "Romeo", "Sierra",
  "Tango", "Uniform", "Victor", "Whiskey", "X-ray", "Yankee",
  "Zulu"};
 
 public MonDeuxiemeProgramme(MaFrame frame){
  frameAttachee = frame;
 }
 
 public void ajouterElementAleatoire(){
  Random r = new Random();
  int valeur = r.nextInt(26);
  
  frameAttachee.getModele().addElement(quelquesDonnees[valeur]);
 }
 
}

Résultat après quelques seconds :

JList (2) : Exemple avec écouteur (Listener) sur la liste elle-même

Ce code montre l'utilisation d'un écouteur (Listener) sur la liste elle-même pour détecter et gérer l'interaction entre cette dernière et l'utilisateur.

Ce code est le deuxième dans une série d'articles qui montrent l'utilité u modèle MVC respecté par les composants Swing et qui devient nécessaire pour les composants qui affichent plusieurs données.

Un premier exemple (avec une explication détaillée sur la création d'une JList avec un DefaultListModel) se trouve ici.

Dans ce deuxième code, la liste est associée à un écouteur pour surveiller les actions de sélection et de désélection des éléments de la liste.

Trois mode de sélection peuvent être définis pour une liste. La méthode setSelectionMode() prend un entier qui détermine le mode. Pour simplifier l'utilisation, les trois valeurs sont déclarées comme des constantes dans la classe ListSelectionModel avec des noms assez parlants. Elles sont :

• ListSelectionModel.SINGLE_SELECTION 
• ListSelectionModel.SINGLE_INTERVAL_SELECTION
• ListSelectionModel.MULTIPLE_INTERVAL_SELECTION

ListSelectionMode (JDK 7)

Dans cet exemple, deux modes seront démontrés.

Pour pouvoir récupérer les changements dans la sélection, il suffit d'ajouter un ListSelectionListener. Ce dernier définit une seule méthode : public void valueChanged(ListSelectionEvent e). Malgré que l’événement ListSelectionEvent permet de récupérer toutes les informations utiles sur le changement dans la sélection, il est possible de faire appel à des méthodes dans la classe JList directement.

ListSelectionEvent

Néanmoins, les méthodes à appeler dépendent du modèle de sélection utilisé. En effet, si le mode de sélection est "SINGLE_SELECTION" alors il n'est pas pratique de faire appel aux méthodes qui récupèrent "la liste des éléments sélectionnés".

Pour basculer entre les deux modes de sélection démontrer, deux JRadioButton sont utilisés. Les deux sont associés à un écouteur (ChangeListener) pour surveiller le changement de la sélection et ainsi changer le mode de sélection de la liste.

ChangeListener

JRadioButton

Ainsi la partie la plus importante du code est :

 public void valueChanged(ListSelectionEvent e){
  if(uniqueSelection){
   
   int indice = liste.getSelectedIndex();
   
   if(indice != -1){
    String valeur = (String)liste.getSelectedValue();
    lblSelection.setText(valeur + "(" + indice + ")");
   }
   
  }else{
   
   int[] indices = liste.getSelectedIndices();
   List<String> valeurs = liste.getSelectedValuesList();
   
   String message = "";
   for(int i = 0; i < valeurs.size(); i++){ 
    message += valeurs.get(i) + "(" + indices[i] + ") ";
   }
   lblSelection.setText(message);
   
  }
 }

Le code complet :

import javax.swing.*;
import javax.swing.event.*;
import java.awt.*;
import java.awt.event.*;
import java.util.List;

public class ExempleSelectionJList 
  extends JFrame 
   implements ChangeListener, ListSelectionListener{
 
 JList liste;
 DefaultListModel<String> modele;
 
 String[] quelquesDonnees = new String[]{"Alfa",
  "Bravo", "Charlie", "Delta", "Echo", "Foxtrot", "Golf",
  "Hotel", "India", "Juliett", "Kilo", "Lima", "Mike",
  "November", "Oscar", "Papa", "Quebec", "Romeo", "Sierra",
  "Tango", "Uniform", "Victor", "Whiskey", "X-ray", "Yankee",
  "Zulu"};
 
 JRadioButton rdoUnique, rdoMultiple;
 ButtonGroup groupe;
 boolean uniqueSelection;
 
 JLabel lblSelection;
 JPanel pnlAjouter;
 
 public ExempleSelectionJList(){
  
  setTitle("Exemple Simple JList");
  setSize(800, 400);
  setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  
  modele = new DefaultListModel();
  liste = new JList(modele);
  liste.addListSelectionListener(this);
  
  creerFormulaire();
  remplirListe();
  
  getContentPane().add(pnlAjouter, BorderLayout.CENTER);
  getContentPane().add(new JScrollPane(liste), BorderLayout.WEST);
  
 }
 
 public void creerFormulaire(){
  
  rdoUnique = new JRadioButton("Choix Unique");
  rdoUnique.setBounds(20, 20, 150, 30);
  rdoMultiple = new JRadioButton("Choix Multiple");
  rdoMultiple.setBounds(190, 20, 150, 30);
  
  rdoUnique.addChangeListener(this);
  rdoMultiple.addChangeListener(this);
  
  groupe = new ButtonGroup();
  groupe.add(rdoUnique);
  groupe.add(rdoMultiple);
  
  rdoUnique.setSelected(true);
  uniqueSelection = true;
  
  lblSelection = new JLabel("La sélection s'affiche ici");
  lblSelection.setBounds(20, 70, 450, 30);
  
  
  pnlAjouter = new JPanel();
  pnlAjouter.setLayout(null);
  pnlAjouter.add(rdoUnique);
  pnlAjouter.add(rdoMultiple);
  pnlAjouter.add(lblSelection);
  
 }
 
 public void remplirListe(){
  for(int i = 0; i < quelquesDonnees.length; i++)
   modele.addElement(quelquesDonnees[i]);
 }
 
 public void valueChanged(ListSelectionEvent e){
  if(uniqueSelection){
   
   int indice = liste.getSelectedIndex();
   
   if(indice != -1){
    String valeur = (String)liste.getSelectedValue();
    lblSelection.setText(valeur + "(" + indice + ")");
   }
   
  }else{
   
   int[] indices = liste.getSelectedIndices();
   List<String> valeurs = liste.getSelectedValuesList();
   
   String message = "";
   for(int i = 0; i < valeurs.size(); i++){ 
    message += valeurs.get(i) + "(" + indices[i] + ") ";
   }
   lblSelection.setText(message);
   
  }
 }
 
 public void stateChanged(ChangeEvent e){
  uniqueSelection = rdoUnique.isSelected();
  if(uniqueSelection)
   liste.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
  else
   liste.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
 }
 
 public static void main (String args[]) {
  
  (new ExempleSelectionJList()).setVisible(true);
 }
}

Quelques résultats :