bouton à partir d'une autre classe

Version imprimable

Bonjour,
je suis débutant en java Swing et je souhaite écrire un petit programme avec trois boutons et une TextField. Bouton "Afficher" qui affiche le message, bouton "Effacer" qui l'efface et le troisième qui le modifie. Mon souci est le troisième car je souhaite le mettre dans une autre classe à part. Voici mon code et merci de me corriger si possible la méthode actionPerformed(ActionEvent e) et ça m'aiderait à mieux comprendre car malgré plusieurs tutos je n'arrive toujours pas à assimiler son fonctionnement. Merci d'avance pour vos retours.

Code:

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
 
package afficheEffaceMassage;
 
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
 
public class Principale extends JFrame implements ActionListener{
	private static final long serialVersionUID = -1299576399713920690L;
	private JButton btnAfficher= new JButton("Afficher");
	private JButton btnEffacer= new JButton("Effacer");
	private JButton btnModifier= new JButton("Modifier");
	protected JTextField texte= new JTextField(10);
	protected JLabel label= new JLabel();
 
	public Principale() {
		super("Message à afficher");
		setSize(400, 200);
		JPanel container = new JPanel();
		JPanel pan1 = new JPanel();
		JPanel pan2 = new JPanel();
		this.setContentPane(container);
		container.add(pan2);
		container.add(pan1);
		pan1.add(texte);
		pan2.add(btnAfficher);
		pan2.add(btnEffacer);
		pan2.add(btnModifier);
		//Associer une action aux deux boutons
		btnAfficher.addActionListener(this);
		btnEffacer.addActionListener(this);
		btnModifier.addActionListener(this);
		this.add(pan2);
		this.add(pan1);
		setDefaultCloseOperation(DISPOSE_ON_CLOSE);
		setLocationRelativeTo(null);
		setVisible(true);
 
	}
 
	@Override
	public void actionPerformed(ActionEvent event) {
		if(event.getSource()==btnAfficher) {
			//quand on clique sur le boutton afficher "Bonjour" s'affiche dans la zone de texte JTextField
			texte.setText("Bonjour");
			texte.setBackground(Color.RED);
		}else if(event.getSource()==btnEffacer) {
			//quand on clique sur le boutton Effacer le contenu de la zone de texte JTextField est effacé
			texte.setText(" ");
			texte.setBackground(Color.WHITE);
		}
	}
	public JTextField getTexte() {
		return texte;
	}
	public void setTexte(JTextField texte) {
		this.texte = texte;
	}
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
package afficheEffaceMassage;
 
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
import javax.swing.JTextField;
 
public class BtnModifier implements ActionListener{
 
	@Override
	public void actionPerformed(ActionEvent e) {
		setText("Bonsoir");
	}
}

Code:

1
2
3
4
5
6
7
8
9
10
11
 
 
package afficheEffaceMassage;
 
public class Main {
 
	public static void main(String[] args) {
		Principale essai= new Principale();
	}
 
}

Salut,
La classe JTextField sert pour définir un champ de saisie. Dans ton code, tu t'en sers juste pour afficher, donc un JLabel serait plus approprié. Est-ce bien un JTextField que tu veux utiliser ?
Ensuite, la méthode setTexte(JTextField) pose un problème. Quel intérêt de changer le composant de saisie par l'extérieur de la classe ? Est-ce que le but n'est pas seulement de pouvoir changer le texte ?

En tout cas, s'il s'agit de changer le champ, le code de setTexte() pose un problème : tu modifies la variable de classe, texte , mais le composant n'est pas changé dans la JFrame. Cela induit une incohérence et après l'appel de setTexte() de Principale, les textes affichés ne seront plus modifiés par les actions sur les boutons. Il faudrait plutôt :
Code:

1 2 3 setTexte(String texte) { this.texte.setText(texte); }
Pour ton problème, de bouton dans une autre classe, à priori, tu cherches à appeler la méthode setTexte() de Principale dans actionPerformed. Dans tous les cas, en Java, pour pouvoir appeler une méthode d'un objet, il faut une référence sur cet objet. Le plus simple est donc de passer cette référence au constructeur de la classe et de la stocker dans la classe :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 public class BtnModifier implements ActionListener{ private Principale fenetre; // pour stocker la référence public BtnModifier(Principale fenetre) { // pour pouvoir passer la référence super("Modifier"); // pour le texte du bouton this.fenetre=fenetre; // stockage de la référence addActionListener(this); // pour que lorsqu'on actionne le bouton, le code de la méthode actionPerformed ci-après s'exécute } @Override public void actionPerformed(ActionEvent e) { this.fenetre.setTexte("Bonsoir"); // utilisation de la référence, pour modifier le texte du champ affiché dans la fenêtre Principale } }
Et dans Principale :

Code:

private JButton btnModifier= new BtnModifier(this); // on passe la référence de la fenêtre

ii faut bien sûr supprimer

Code:

btnModifier.addActionListener(this);

, sinon on exécutera les deux méthodes actionPerformed lors du clic sur le bouton, celle de BtnModifier et celle de Principale.
Par ailleurs, remarque. Je sais qu'on voit dans plein de tutoriels cette forme d'implémentation où l'implémentation de ActionListener est faite sur la classe principale. Personnellement je trouve que c'est à minima une erreur, voire une stupidité. Déjà, ça ouvre la méthode à l'appel par d'autres classes, ce qui ne sert à rien, et ouvre à des risques potentiels. Si c'est nécessaire, on préféra une méthode indirecte, qui permet le contrôle. En plus ça oblige à faire ces tests pour connaître le bouton d'origine de l'action, ce qui complique inutilement le code. Enfin, ça fait implémenter du code dans une classe où aucune logique ne saurait justifier qu'il doive se trouver là, ou tout de moins, ce serait le plus mauvais endroit.
Il est préférable d'utiliser une classe anonyme, voire une expression lambda ou une référence de méthode. Ainsi ça ferme toute possibilité d'action extérieure sur le bouton, ça rend le code plus simple et plus souple(plus facilement modifiable (introduction d'action voire de commande)).

Ainsi :
Code:

1 2 3 4 5 6 7 btnAfficher.addActionListener(new ActionListener() { @Override public void actionPerformed(ActionEvent event) { texte.setText("Bonjour"); texte.setBackground(Color.RED); } })
Avec une expression lambda ça devient encore plus simple :
Code:

1 2 3 4 5 6 btnAfficher.addActionListener(event-> { texte.setText("Bonjour"); texte.setBackground(Color.RED); } )
Avec une expression lambda, avec une méthode dans Principale,
Code:

1 2 3 4 public void afficherBonjour() { texte.setText("Bonjour"); texte.setBackground(Color.RED); }
Code:

1 2 btnAfficher.addActionListener(event-> afficherBonjour()} )
Avec cette méthode, on voit que d'avoir une classe de bouton spécifique est moins justifié. Il est possible qu'il y ait un logique particulière avec des variables peut-être, mais dans ce cas, on fera une classe normale, qui n'est pas un bouton et on l'impliquera dans l'écouteur d’événement :
Code:

1 2 3 4 5 6 7 JeSaisPasQuoiHandler btnModifierHandler = new JeSaisPasQuoiHandler(...les paramètres nécessaires...); btnModifier.addActionListener(event-> { btnModifierHandler.handle(/* event ou pas, ou autre chose... */); } )
avec une classe JeSaisPasQuoiHandler qui a une méthode handle() avec ou sans paramètre selon les besoins...

16/09/2019, 18h54
rmed92

Merci beaucoup Joel.drigo pour ces éclaircissements.

Re-Bonjour joel.drigo,

je reviens sur ta solution pour te signaler que j'ai modifié le code comme tu as demandé sauf que dans la classe BtnModifier j'ai le message d'erreur suivant : The method addActionListener(BtnModifier) is undefined for the type BtnModifier sur la ligne que j'ai mis en rouge : addActionListener(this)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 package afficheEffaceMassage; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; public class BtnModifier implements ActionListener{ private Principale fenetre; // pour stocker la référence public BtnModifier(Principale fenetre) { // pour pouvoir passer la référence super(); // pour le texte du bouton this.fenetre=fenetre; // stockage de la référence addActionListener(this); // pour que lorsqu'on actionne le bouton, le code de la méthode actionPerformed ci-après s'exécute } @Override public void actionPerformed(ActionEvent e) { this.fenetre.setLabel("Bonsoir"); // utilisation de la référence, pour modifier le texte du champ affiché dans la fenêtre Principale } }
et merci d'avance pour ton aide.

17/09/2019, 18h00
joel.drigo

Ah oui j'ai copié un peu vite ton code sans voir qu'il y avait une erreur...

Au lieu de public class BtnModifier implements ActionListener{ il fallait lire public class BtnModifier extends JButton {

OK, MERCI j'ai vu l'erreur .
en tous cas avec les expressions Lambda c'est plus pratique et facile.
Dans la classe Principale :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
// Expression Lambda pour chaque bouton
btnAfficher.addActionListener(e->{
			texte.setText("Bonjour");
			texte.setBackground(Color.RED);
		    });
btnEffacer.addActionListener(e->{
			texte.setText(" ");
			texte.setBackground(Color.WHITE);
			});
btnModifier.addActionListener(e->{
			texte.setText("Bonsoir ");
			texte.setBackground(Color.GREEN);
			});

MERCIIIIIIIIIIII

Note que comme tes trois boutons font la même chose avec des données différentes, tu pourrais faire une méthode :

Code:

1
2
3
4
public void afficher(String texte, Color color) {
    this.texte.setText(texte);
    this.texte.setBackground(color);
}

Code:

1
2
3
4
5
 
// Expression Lambda pour chaque bouton
btnAfficher.addActionListener(e->afficher("Bonjour",Color.RED));
btnEffacer.addActionListener(e->afficher("",Color.WHITE));
btnModifier.addActionListener(e->afficher("Bonsoir ",Color.GREEN));