Aller au menu - Aller au contenu

[Plan du site] Vous êtes ici --- > Le Site du Zéro > Les tutoriels > Officiels > Programmation > Programmation en Java > Java et la programmation événementielle > Les listes : l'objet JComboBox > Lecture du tutoriel

Les listes : l'objet JComboBox

Avatar
Auteur : cysboy
Difficulté : Connaisseur (3 / 5)
Visualisations : 9 887

Plus d'informations Plus d'informations
Nous allons continuer à explorer les objets que nous propose swing.
Ici, nous parlerons des listes de choix ou JComboBox, nous pourrons ainsi améliorer notre animation... :D

Let's go, ZérO boys !
Sommaire du chapitre :
Icône du chapitre
Chapitre précédent Sommaire Chapitre suivant

Première utilisation

Comme à l'accoutumée, nous allons d'abord utiliser cet objet dans un contexte vierge de tout code... Alors créez-vous un projet avec une classe contenant la méthode main et une classe qui sera héritée de JFrame.

Dans cet exemple, nous allons bien évidemment utiliser une liste, donc créez en une...
Ce type d'objet ne possède pas de constructeur avec un libellé en paramètre, comme les boutons par exemple ! Il faut donc mettre un JLabel à côté ! :D


Voici un premier code :

Code : Java
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
 
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
 
 
public class Fenetre extends JFrame {
        
        private JPanel container = new JPanel();
        private JComboBox combo = new JComboBox();
        private JLabel label = new JLabel("Une ComboBox");
        
        public Fenetre(){
        
        this.setTitle("Animation");
        this.setSize(300, 300);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setLocationRelativeTo(null);
 
        container.setBackground(Color.white);
        container.setLayout(new BorderLayout());
                        
        JPanel top = new JPanel();
        top.add(label);
        top.add(combo);
        
        container.add(top, BorderLayout.NORTH);
        this.setContentPane(container);
        this.setVisible(true);                   
        }
 
}


Et l'aperçu :

Image utilisateur


Vous constatez que votre objet est ridiculement petit... :-°
Mais vous connaissez le remède !

Code : Java
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
 
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
 
 
public class Fenetre extends JFrame {
        
        private JPanel container = new JPanel();
        private JComboBox combo = new JComboBox();
        private JLabel label = new JLabel("Une ComboBox");
        
        public Fenetre(){
        
        this.setTitle("Animation");
        this.setSize(300, 300);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setLocationRelativeTo(null);
 
        container.setBackground(Color.white);
        container.setLayout(new BorderLayout());
        
        combo.setPreferredSize(new Dimension(100,20));
                        
        JPanel top = new JPanel();
        top.add(label);
        top.add(combo);
        
        container.add(top, BorderLayout.NORTH);
        this.setContentPane(container);
        this.setVisible(true);            
        }
}


Et voilà :

Image utilisateur


Et comment on renseigne cette liste ?

Nous y voilà ! Pour ça, il suffit d'utiliser la méthode addItem(Object obj).

Vous devez savoir que lorsque l'objet affiche les éléments ajoutés, celui-ci appelle la méthode toString() des objets ajoutés... Dans cet exemple, nous avons utilisé des objets String, mais essayez avec un autre objet et vous verrez...


Voici le nouveau code :

Code : Java
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
 
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
 
 
public class Fenetre extends JFrame {
        
        private JPanel container = new JPanel();
        private JComboBox combo = new JComboBox();
        private JLabel label = new JLabel("Une ComboBox");
        
        public Fenetre(){
        
        this.setTitle("Animation");
        this.setSize(300, 300);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setLocationRelativeTo(null);
 
        container.setBackground(Color.white);
        container.setLayout(new BorderLayout());
        
        combo.setPreferredSize(new Dimension(100,20));
        combo.addItem("Option 1");
        combo.addItem("Option 2");
        combo.addItem("Option 3");
        combo.addItem("Option 4");
                
        JPanel top = new JPanel();
        top.add(label);
        top.add(combo);
        
        container.add(top, BorderLayout.NORTH);
        this.setContentPane(container);
        this.setVisible(true);            
        }
}


Et le résultat :

Image utilisateur


Vous pouvez utiliser le constructeur qui prend un tableau d'objets en paramètre afin de renseigner tous les éléments d'un coup !


Ceci est donc équivalent :

Code : Java
1
2
String[] tab = {"Option 1", "Option 2", "Option 3", "Option 4"};
combo = new JComboBox(tab);


Vous pouvez présélectionner un choix avec la méthode setSelectedIndex(int index). Vous avez aussi la possibilité de changer la couleur d'écriture, la couleur de fond, la police exactement comme un JLabel.

Maintenant que vous voyez comment fonctionne cet objet, nous allons voir comment communiquer avec lui.

L'interface ItemListener

Cette interface à une méthode à redéfinir. Celle-ci est appelée lorsqu'un élément a changé d'état !
Vu qu'un exemple est toujours plus éloquent, voici un code implémentant cette interface :

Code : Java
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
 
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
 
 
public class Fenetre extends JFrame {
        
        private JPanel container = new JPanel();
        private JComboBox combo = new JComboBox();
        private JLabel label = new JLabel("Une ComboBox");
        
        public Fenetre(){
        
        this.setTitle("Animation");
        this.setSize(300, 300);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setLocationRelativeTo(null);
 
        container.setBackground(Color.white);
        container.setLayout(new BorderLayout());
               
        String[] tab = {"Option 1", "Option 2", "Option 3", "Option 4"};
        
        combo = new JComboBox(tab);
        //Ajout du listener
        combo.addItemListener(new ItemState());
        combo.setPreferredSize(new Dimension(100,20));
        combo.setForeground(Color.blue);
       
        JPanel top = new JPanel();
        top.add(label);
        top.add(combo);
        
        container.add(top, BorderLayout.NORTH);
        this.setContentPane(container);
        this.setVisible(true);            
        }
 
        /**
         * Classe interne implémentant l'interface ItemListener
         */
        class ItemState implements ItemListener{
 
                public void itemStateChanged(ItemEvent e) {
                        System.out.println("événement déclenché sur : " + e.getItem());
                }               
        }
        
}


Dans mon exemple, j'ai cliqué sur :

Ce qui me donne :

Image utilisateur


Vous voyez bien que lorsque vous cliquez sur une option non sélectionnée, notre objet change d'abord l'état de l'option précédente (l'état passe en DESELECTED) avant de changer l'état de l'option choisie (celle-ci passe à l'état SELECTED).
Vous pouvez donc suivre très facilement l'état de vos éléments grâce à cette interface ; cependant, pour plus de simplicité, nous utiliserons l'interface ActionListener pour récupérer l'option sélectionnée !

Voici un code implémentant cette interface :

Code : Java
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
 
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
 
 
public class Fenetre extends JFrame {
        
        private JPanel container = new JPanel();
        private JComboBox combo = new JComboBox();
        private JLabel label = new JLabel("Une ComboBox");
        
        public Fenetre(){
        
        this.setTitle("Animation");
        this.setSize(300, 300);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setLocationRelativeTo(null);
 
        container.setBackground(Color.white);
        container.setLayout(new BorderLayout());
               
        String[] tab = {"Option 1", "Option 2", "Option 3", "Option 4"};
        
        combo = new JComboBox(tab);
        //Ajout du listener
        combo.addItemListener(new ItemState());
        combo.addActionListener(new ItemAction());
        combo.setPreferredSize(new Dimension(100,20));
        combo.setForeground(Color.blue);
       
        JPanel top = new JPanel();
        top.add(label);
        top.add(combo);
        
        container.add(top, BorderLayout.NORTH);
        this.setContentPane(container);
        this.setVisible(true);            
        }
 
        /**
         * Classe interne implémentant l'interface ItemListener
         */
        class ItemState implements ItemListener{
 
                public void itemStateChanged(ItemEvent e) {
                        System.out.println("ItemListener : événement déclenché sur : " + e.getItem());
                }               
        }
        
        class ItemAction implements ActionListener{
 
                public void actionPerformed(ActionEvent e) {
                        System.out.println("ActionListener : action sur " + combo.getSelectedItem());
                }               
        }
        
}


Et le résultat :

Image utilisateur


Vous constatez qu'avec une telle implémentation, nous pouvons récupérer l'option sur laquelle l'action a été produite. L'appel de la méthode getSelectedItem() retourne la valeur de l'option sélectionnée ; une fois ceci récupérée, nous allons pouvoir travailler avec notre liste ! :D

Il y a d'autres méthodes pour récupérer le contenu d'une liste... Je vous invite à chercher ce genre d'information. ^^
En effet, une information apprise par nos propres moyens s'oublie beaucoup moins vite que celle qu'on vous sert toute cuite sur un plateau...


Maintenant que nous savons comment récupérer les informations dans une liste, je vous invite à continuer notre animation.

Changer la forme de notre animation

Comme le titre l'indique, nous allons faire en sorte que notre animation ne se contente plus d'afficher un rond... Nous allons pouvoir choisir quelle forme nous voulons afficher ! ^^

Bien sûr, je ne vais pas vous faire réaliser toutes les formes possibles et imaginables... Je vous en fournis quelques-unes et, si le coeur vous en dit, ajoutez-en de votre composition !

Très bien : pour arriver à faire ceci, nous allons dynamiser un peu notre classe Panneau, celle-ci devra pouvoir peindre différentes forme selon notre bon vouloir.
Pour y parvenir, nous allons ajouter une variable d'instance de type String qui contiendra l'intitulé de la forme que nous souhaitons dessiner - appelons-la forme - et ajoutons un mutateur afin de pouvoir redéfinir cette variable.
Notre méthode paintComponent doit pouvoir dessiner la forme demandée ; ici, deux cas de figures se profilent :


J'ai l'habitude de procéder de la deuxième façon pour éviter les conditions à rallonges dans mes méthodes...
Faites toutefois attention lorsque vous faites ceci ! Il se peut que votre classe devienne énorme et que vous vous y perdiez ! Nous verrons, dans une partie traitant des design patterns, que lorsque votre code a des portions de code contenant beaucoup de conditions, il vaut mieux programmer une implémentation, mais nous n'en sommes pas encore là... :D


Nous allons donc développer une méthode privée, appelons-la draw(Graphics g), qui aura pour tâche de dessiner la forme voulue. Nous passerons l'objet Graphics utilisé dans la méthode paintComponent afin qu'elle puisse l'utiliser, et c'est dans cette méthode que nous mettrons nos conditions.

Je vous propose les formes suivantes :


Ce qui veut dire que notre liste contiendra ces choix, et le rond sera le premier !
Nous créerons aussi une implémentation d'ActionListener dans une classe interne pour gérer les actions sur notre liste ; je l'ai appelée FormeListener, c'est fou ce que je suis original...

Une fois n'est pas coutume, voici ce que vous devez obtenir :

Image utilisateurImage utilisateurImage utilisateurImage utilisateur


Essayez de trouver comment faire ces formes... Il n'y a rien de compliqué, je vous assure ! Bon, l'étoile est peut-être un peu plus difficile que le reste, mais elle n'est pas insurmontable... :ange:

Voici les codes :

Secret (cliquez pour afficher)

La classe

Panneau

Code : Java
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
import java.awt.Color;
import java.awt.Font;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
 
import javax.swing.JPanel;
 
public class Panneau extends JPanel {
 
        private int posX = -50;
    private int posY = -50;
    private String forme = "ROND";
    
    
    public void paintComponent(Graphics g){
            //On décide d'une couleur de fond pour notre rectangle
            g.setColor(Color.white);
            //On dessine celui-ci afin qu'il prenne toute la surface
            g.fillRect(0, 0, this.getWidth(), this.getHeight());
            //On redéfinit une couleur pour notre rond
            g.setColor(Color.red);
            //On délègue la méthode de dessin à la méthode draw()
            draw(g);       
    }
 
    private void draw(Graphics g){
        
        if(this.forme.equals("ROND")){
                g.fillOval(posX, posY, 50, 50); 
        }
        if(this.forme.equals("CARRE")){
                g.fillRect(posX, posY, 50, 50);
        }
        if(this.forme.equals("TRIANGLE")){
                
                //calcul des sommets                    
                //Le sommet 1 est à la moitié du côté supérieur du carré de 50  
                int s1X = posX + 25;
                int s1Y = posY;
                //Le sommet deux est en bas à droite
                int s2X = posX + 50;
                int s2Y = posY + 50;
                //Le sommet Trois en bas à gauche
                int s3X = posX;
                int s3Y = posY + 50;
                
                // Nous créons deux tableaux de coordonnées
                int[] ptsX = {s1X, s2X, s3X};
                int[] ptsY = {s1Y, s2Y, s3Y};
                
                //Et nous utilisons la méthode fillPolygon
                g.fillPolygon(ptsX, ptsY, 3);
        }
        if(this.forme.equals("ETOILE")){
                
                //Pour l'étoile, je me contente de tracer des lignes
                //dans le carré correspondant à peu près à une étoile...
                //Mais ce code peut être amélioré !
                int s1X = posX + 25;
                int s1Y = posY;
                int s2X = posX + 50;
                int s2Y = posY + 50;                    
                g.drawLine(s1X, s1Y, s2X, s2Y);
                
                int s3X = posX;
                int s3Y = posY + 17;
                g.drawLine(s2X, s2Y, s3X, s3Y);
                
                int s4X = posX + 50;
                int s4Y = posY + 17;
                g.drawLine(s3X, s3Y, s4X, s4Y);                 
                                
                int s5X = posX;
                int s5Y = posY + 50;
                g.drawLine(s4X, s4Y, s5X, s5Y);                 
                g.drawLine(s5X, s5Y, s1X, s1Y);  
        }
        
    }
    
    
    public void setForme(String form){
        this.forme = form;
    }
    
    public int getPosX() {
            return posX;
    }
 
    public void setPosX(int posX) {
            this.posX = posX;
    }
 
    public int getPosY() {
            return posY;
    }
 
    public void setPosY(int posY) {
            this.posY = posY;
    }
}


La classe

Fenetre

Code : Java
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
 
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
 
public class Fenetre extends JFrame{
 
        private Panneau pan = new Panneau();
        private JButton bouton = new JButton("Go");
        private JButton bouton2 = new JButton("Stop");
    private JPanel container = new JPanel();
    private JLabel label = new JLabel("Choix de la forme");
    private int compteur = 0;
    private boolean animated = true;
    private boolean backX, backY;
    private int x,y ;
    private Thread t;
    
    private JComboBox combo = new JComboBox();
    
    public Fenetre(){
           
            this.setTitle("Animation");
            this.setSize(300, 300);
            this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            this.setLocationRelativeTo(null);
 
            container.setBackground(Color.white);
            container.setLayout(new BorderLayout());
            container.add(pan, BorderLayout.CENTER);
            
            bouton.addActionListener(new BoutonListener());             
            bouton2.addActionListener(new Bouton2Listener());
            bouton2.setEnabled(false);
            
            JPanel south = new JPanel();
            south.add(bouton);
            south.add(bouton2);
            container.add(south, BorderLayout.SOUTH);
            
            combo.addItem("ROND");
            combo.addItem("CARRE");
            combo.addItem("TRIANGLE");
            combo.addItem("ETOILE");
            
            combo.addActionListener(new FormeListener());
            
            JPanel top = new JPanel();
            top.add(label);
            top.add(combo);
            
            container.add(top, BorderLayout.NORTH);
            this.setContentPane(container);
            this.setVisible(true);            
                        
    }
        
    
        private void go(){
                x = pan.getPosX();
                y = pan.getPosY();
           while(this.animated){
                
                if(x < 1)backX = false;
                if(x > pan.getWidth()-50)backX = true;               
                if(y < 1)backY = false;
                if(y > pan.getHeight()-50)backY = true;                        
                if(!backX)pan.setPosX(++x);
                else pan.setPosX(--x);
                if(!backY) pan.setPosY(++y);
                else pan.setPosY(--y);
                pan.repaint();
 
               try {
                    Thread.sleep(3);
               } catch (InterruptedException e) {
                    e.printStackTrace();
               }
           }       
        }
 
 
        /**
         * classe qui écoute notre bouton
         */
        public class BoutonListener implements ActionListener{
 
                /**
                 * Redéfinitions de la méthode actionPerformed
                 */
                public void actionPerformed(ActionEvent arg0) {
                        animated = true;
                        t = new Thread(new PlayAnimation());
                        t.start();
                        bouton.setEnabled(false);
                        bouton2.setEnabled(true);
                        
                }
                
        }
        
        /**
         * classe qui écoute notre bouton2
         */
        class Bouton2Listener  implements ActionListener{
 
                /**
                 * Redéfinitions de la méthode actionPerformed
                 */
                public void actionPerformed(ActionEvent e) {
                        animated = false;       
                        bouton.setEnabled(true);
                        bouton2.setEnabled(false);
                }
                
        }       
        
        class PlayAnimation implements Runnable{
 
                public void run() {
                        go();                   
                }               
        }
        
        
        class FormeListener implements ActionListener{
 
                public void actionPerformed(ActionEvent e) {
                        //la méthode retourne un Object puisque nous passons des Object dans une liste
                        //Il faut donc utiliser la méthode toString() pour retourner un String (ou utiliser un cast)
                        pan.setForme(combo.getSelectedItem().toString());
                }               
        }       
}




Et voilà le travail !
Vous avez vu qu'il n'y avait rien de sorcier ici. En fait, vu que vous avez l'habitude d'utiliser des objets graphiques et des implémentations d'interfaces, les choses vont s'accélérer car le principe reste le même pour tous les objets graphiques de base ! :D

Bon, j'ai tout de même fait un léger topo et un mini-QCM...

Ce qu'il faut retenir


Q.C.M.

Quelle méthode permet d'ajouter des éléments dans une liste ?
Quelle méthode permet de retourner l'élément sélectionné ?
Quel type de donnée retourne la méthode citée dans la deuxième question ?

Statistiques de réponses au QCM


Rien de bien méchant ici, vous êtes habitués à utiliser les objets swing et les interfaces...
Continuons notre petit tour parmi les objets du package javax.swing, alors ! En route vers : les cases à cocher !
Chapitre précédent Sommaire Chapitre suivant
Retour en haut Retour en haut


Créé : le 21/06/2006 à 15:02:22
Modifié : le 04/11/2008 à 19:33:09
Avancement : 0%
Licence : Copie non autorisée

Changer de design | En savoir plus | Plan du site | Politique d'accessibilité | Règles | RSS tutoriels | RSS news
Édité par Simple IT SARL : Nous contacter | Notre blog | Revue de presse | Publicité

Y'a plus rien à lire, faut remonter maintenant !

Hébergement web - Correction de tutoriels - Créer un site
Vous souhaitez apparaître ici ? Contactez-nous.

Nombre de connectés 551 Zéros connectés | Requêtes SQL 8 requêtes | Temps de génération de la page : Total (SQL) 0.0325s (0.0148s)