Discussion :

[alex2746]

Bonjour,
J'ai un JPanel (PanelPrincipal) et dans ce JPanel un autre JPanel (PanelControle).

Dans PanelControle j'ai un checkbox. Quand je modifie la valeur de ce checkbox (donc que je clique dessu) je veux qu'un "signal" soit envoyé à PanelPrincipal pour lui dire que l'état du checkbox a changé (lui donner le nouvel état) et faire un traitement dans PanelPrincipal en fonction de cela. Pour ce faire je dois utiliser le système Observateur/Observé.

Pourriez-vous m'aider?

Merci d'avance.

[joel.drigo]

Salut,

tout d'abord tu peux écouter les changements d'état de ta checkbox, en supposant que ton interface soit SWING, en enregistrant un ActionListener sur ta JCheckBox de cette manière :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
checkbox.addActionListener(new ActionListener() {
 
	@Override
	public void actionPerformed(ActionEvent e) {
	    if ( ((JCheckBox)e.getSource()).isSelected() )  {
	      // code qui réagit à la case cochée
	    } else {
	      // code qui réagit à la case décochée
            }
	}
 
});

Ensuite comme ta checkbox est dans un panel qui se trouve dans un autre panel et que c'est ce dernier qui doit réagir aux changements d'état de la checkbox, il est nécessaire que le panel principal soit référençable dans l'écouteur d'évenement enregistré sur la checbox.

Il y'a une multitude de façons de procéder : PanelControl peut par exemple avoir son propre système d'évenements qui collecte tous les évenements de tous les composants qu'il contient.

Pour faire un système plus simple, pour commencer, tu peux simplement faire une méthode dans PanelControl de ce type :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
public void addCheckBoxActionListener(ActionListener actionListener) {
checkbox.addActionListener(actionListener);
}

et dans ton PanelPrincipal, tu auras :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
...
 
panelControl = new PanelControle();
 
...
 
panelControl.addCheckBoxActionListener(new ActionListener() {
 
	@Override
	public void actionPerformed(ActionEvent e) {
	    if ( ((JCheckBox)e.getSource()).isSelected() )  {
	      // code qui réagit à la case cochée
	    } else {
	      // code qui réagit à la case décochée
            }
	}
 
});
 
...

[alex2746]

Parfait, ça fonctionne :-)

Mais pourriez-vous également me montrer comment faire avec le système Observateur/Observé?

Merci d'avance !

[joel.drigo]

L'implémentation du pattern Observable/Observé ne sera pas très différente

Pareil, il y a plusieurs façon de procéder, mais procédons au cas le plus simple : créons une classe d'observable qui gère l'état de ta checkbox : par exemple,
cela peut être une inner class de PanelControl

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
private static class CheckBoxObservable extends Observable {
 
    private JCheckBox checkbox;
    public CheckBoxObservable(JCheckbox checkbox) {
         this.checkbox=checkbox;
         this.checkbox.addActionListener(new ActionListener() {
              public void actionPerformed(ActionEvent e) {
			notifyObservers(checkbox.isSelected());		
		}
         });
    } 
 
}

Dans PanelControl, tu ajoutes une variable membre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

private CheckBoxObservable cbObservable

Dans le code qui créé ta checkbox, après l'avoir créé, tu ajoutes :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
checkbox = new JCheckBox(...
...
cbObservable = new CheckBoxObservable(checkbox);
...

et tu ajoutes une méthode dans ton PanelControl qui permet d'enregistrer ton observer :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
public void addCheckBoxObserver(Observer observer) {
     cbOservable.addObserver(observer);
}

Dans PanelPrincipal, tu peux écrire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
...
panelControl.addCheckboxObserver(new Observer() {
 
    public void update(Observable o, Object arg) {
	 if ( ((Boolean)arg) ) {
              // traitement selected
         }			
         else {
              // traitement not selected 
         }
    }
 
});
...

On voit tout de suite le problème du traitement de la valeur observée : on est obligé de connaitre la façon dont cette valeur est gérée : ici c'est un booléen, mais on aurait aussi plus transmettre la checkbox ou autre chose.

Autre façon d'éviter ça : on peut créer une classe CheckBoxObservable qui ne soit plus une inner classe (ou alors public inner) avec une méthode

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
public boolean isChecked() {
     return checkbox.isSelected();
}

Mais dans ce cas, il faudrait faire dans l'observer :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 if ( ((PanelControl.CheckBoxObservable)o).isChecked() ) {
...
}

et on ne passe éventuellement plus de valeur en argument de l'appel de notifyObservers();

Mais on voit que ça oblige quand même l'appelant à connaitre la classe d'observable : si c'est pour toi et toi seul, c'est pas grave, mais si c'est destiné à être utilisable et réutilisable, il faudra bien documenter. Ou éventuellement fournir ta propre abstraction d'observeur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
public abstract class AbstractCheckboxObserver implements Observer {
 
    public final void update(Observable o, Object arg) {
           checkBoxChanged((CheckBoxObservable)o).isChecked());
    }
 
    protected abstract void checkBoxChanged(boolean checked);
 
}

et modifier la méthode de PanelControl :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
public void addCheckBoxObserver(AbstractCheckboxObserver observer) {
     cbOservable.addObserver(observer);
}

Bon, on pourrait aller plus loin dans les couches intermédiaires, par exemple en faisant une interface au lieu d'une abstraction, qui ne soit même plus un Observer, et que l'observer soit géré en interne par PanelControl : on obtiendrait un système évènementiel similaire à ceux qu'on a déjà dans les composants SWING.