Passage de variables entre class

Version imprimable

Bonjour

je suis actuellement le cours programmation Java pour les enfants et parents et je butte sur la transmission des paramètres entre class.
Voici le code des mes deux class:

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
import javax.swing.*;
import java.awt.GridLayout;
 
public class CalculSimple {
	public static void main(String[] args) {
		JPanel fenetre = new JPanel();
		GridLayout disposition = new GridLayout(4,2,5,5); //Grille de 4 lignes et 2 colonnes espacées de 5 dots
		fenetre.setLayout(disposition); //on affecte la grille à la fenêtre
		//création des composants
		JLabel label1 = new JLabel("Nombre 1: ");
		JTextField nb1 = new JTextField(10);
		JLabel label2 = new JLabel("Nombre 2: ");
		JTextField nb2 = new JTextField(10);
		JLabel label3 = new JLabel("Résultat: ");
		JTextField resultat = new JTextField(10);
		JButton lancer = new JButton("Ajouter");
		JButton retirer = new JButton("Soustraire");
		//Intégration des composants dans la fenêtre
		fenetre.add(label1);
		fenetre.add(nb1);
		fenetre.add(label2);
		fenetre.add(nb2);
		fenetre.add(label3);
		fenetre.add(resultat);
		fenetre.add(lancer);
		fenetre.add(retirer);
		//Création d'un cadre et affectation à la fenêtre
		JFrame cadre = new JFrame("Addition");
		cadre.setContentPane(fenetre);
		cadre.setSize(400,150);
		cadre.setVisible(true);
		//Affectation des listener aux boutons
		Moteur go = new Moteur(); //Moteur est la class qui gère les évènements
		lancer.addActionListener(go);
		retirer.addActionListener(go);
	}
 
}

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
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import javax.swing.JOptionPane;
import javax.swing.JButton;
 
//Class qui est à l'écoute d'un évènement
public class Moteur implements ActionListener {
	CalculSimple calcul; //Instance de la class CalculSimple.
 
	//Fonction constructeur
	Moteur(CalculSimple calcul) {
		this.calcul = calcul; 
	}
 
	//Méthode utilisée dès qu'il y a un évènement
	public void actionPerformed(ActionEvent event){
		JButton touche = (JButton) event.getSource(); //touche est l'instance de l'objet qui a créé l'évènement
		String nTouche = touche.getText();            //nTouche est une variable contenant le texte de la touche indéxée
 
		//Méthode permettant d'afficher une boîte de dialogue
		JOptionPane.showMessageDialog(null,  "Il y a une une action sur la touche:  " + nTouche,"Afficheur d'actions",JOptionPane.WARNING_MESSAGE);
 
		calcul.resultat.setText(nTouche);
 
	}	
}

Le problème est sur la dernière ligne: le paramètre resultat n'est pas reconnu.

Merci de votre aide

Michel

18/01/2016, 13h24
guatto

Bonjour mormic,

tu as essayé avec le mot clé "public" ?

Salut,

De manière générale, toute variable déclaré à l'intérieur d'une méthode n'est visible que par cette méthode.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 public class Test { public void affiche() { String s = "toto"; System.out.println( s ); // OK, car "s" bien est déclarée } public void affiche2() { System.out.println( s ); // Erreur de compilation, la variable "s" n'existe pas dans cette méthode } }
Si tu veux que la variable "s" soit connue de la méthode affiche2(), tu as plusieurs solutions.

- Soit tu lui donnes en paramètre. Ce qui te permet d'appeler cette méthode depuis n'importe quel endroit dans ton code avec la valeur que tu souhaites afficher.
Code:

1 2 3 4 5 public void affiche2( String s ) { System.out.println( s ); // Ok }
- Soit la variable doit être accessible depuis la méthode et dans ce cas on va devoir déclarer la variable "s" comme attribut de la classe Test et non plus comme variable interne à la méthode.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 public class Test { private String s = "toto"; public void affiche() { System.out.println( s ); // OK } public void affiche2() { System.out.println( s ); // OK } }
Cette "visibilité" est valable pour n'importe quelle variable déclaré au sein d'une classe.

Maintenant les choses sont un peu différentes quand tu parles d'accéder à une variable qui n'appartient pas à la classe courante.

Les mots clé public, private, protected vont te permettre de définir comment tu souhaites gérer l’accessibilité d'une variable au sein de ton code (c'est valable aussi pour les méthodes).

Je t'invite à regarder ce cours pour plus de détails (la section sur le mot clé static est intéressante aussi).

Ton problème est donc lié à la "visibilité" de ta variable par rapport ton autre classe. Je te laisse essayer de le résoudre tout seul pour l'instant car c'est un principe fondamental de la programmation objet et qu'il est préférable que tu trouves par toi même ;)

Cdt.

18/01/2016, 16h12
mormic

Merci pour ces réponses mais je pense avoir compris ce que signifiait "public"; d'ailleurs tout est déclaré public dans le code.
Le passage des variables entre méthodes me semble assez clair, ce que je ne vois pas c'est le passage d'un objet d'une class à une autre.
Voilà plusieurs heures que je cherche par moi-même et lorsqu'on ne trouve pas c'est très frustrant.
Ce que je demandait simplement, c'était qu'on me dise ce qui ne va pas dans mon code.
Maintenant si c'est une devinette, je laisse tomber.

Cordialement
18/01/2016, 17h04
thelvin

Ok, ben le problème c'est que tes variables elles sont dans une méthode, et que les variables dans une méthode ne sont pas visibles ailleurs que dans cette méthode. Donc pas visibles dans une autre méthode, pas visibles dans une autre classe, pas visibles nulle part.
Ce qu'il faudrait c'est qu'elles ne soient pas dans une méthode, mais dans ta classe. Genre ta variable CalculSimple calcul, elle n'est pas dans une méthode mais dans la classe, voilà, c'est un exemple de variable qui est pas dans une méthode. Bon ben quand tu veux qu'une variable soit visible tu fais pareil que ça. Mais public ou protected ou quelque chose de ce genre.

Et si tu te demandes comment on fait concrètement, eh ben non, c'est pas une devinette, c'est tout écrit au-dessus, c'est pour ça que ça a été écrit.
19/01/2016, 00h03
Nico02

C'est pas vraiment une devinette puisque que je t'ai donné tous les éléments de réponses (et @thelvin t'a carrément donné la réponse).

Et puis tu dis avoir déclarer toute tes variables en public alors que c'est totalement faux. Toute tes variables sont déclarées à l'intérieur d'une méthode (la méthode main en l’occurrence) et donc ne sont pas accessible en dehors de celle ci (d'où mon petit discours.).

Et tant bien même elles seraient déclarées en tant qu'attributs de ta classe (comme l'attribut "calcul" de ta classe Moteur), sans le mot clé public devant, et ben elles sont pas publique (c'est fou non?).

Le but c'est pas de poser des devinettes pour me faire mousser (moi m'en fou hein), mais plutôt de t'aider à comprendre la source de ton problème. Après si t'as pas le temps de lire et d'essayer de comprendre ce que je te dit, alors oui autant laisser tomber car c'est quand même le B-A BA de la programmation.

Cdt.
19/01/2016, 11h33
mormic

Voilà j'ai compris. Merci à vous deux. Je demandais simplement qu'on me dise cela: "les variables déclarés dans une méthode même si celle-ci est public ne sont pas accessibles en dehors de cette méthode". Je viens de modifier mon code et maintenant cela fonctionne. Mis à part le fait que j'ai été obligé de déclarer toutes mes variables "static" ?? Pour l'instant je n'ai pas compris, mais c'est promis je vais lire et relire pour essayer de comprendre.

Bien cordialement
Michel

Citation:

Envoyé par Nico02

De manière générale, toute variable déclaré à l'intérieur d'une méthode n'est visible que par cette méthode.

C'est la première phrase de mon post quand même :fessee:

Pour ce qui est des variables statique c'est pas la bonne façon de procéder.

Une variable statique est commune à toutes les instances de ta classe -> elle n'existe qu'une seule et unique fois pour tous les objets que tu vas créer. On s'en sert par exemple pour déclarer une constante.
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 // on reprend notre claase de teste public class Test { public static String var; public Test( String s ) { var = s; // on modifie la variable statique via le constructeur de l'objet. } public void affiche() { System.out.println( var ); } public static void main( String[] arg ) // une fonction main pour tester tout ça. { Test o1 = new Test( "toto" ); o1.affiche(); // affiche "toto" Test o2 = new Test( "tata" ); o2.affiche(); // affiche "tata" o1.affiche(); // MAIS ici o1 affichera aussi "tata" !! } }
On voit ici que après la création de l’objet o2, la variable statique "var" a été modifié pour toutes les instances (tous les objets, même crées précédemment) de la classe Test

C'est le même principe pour une fonction statique. Comme elle est commune à toute les instances de ta classe, il n'est pas nécessaire d'instancier un objet pour pouvoir s'en servir.
Code:

1 2 3 4 5 6 7 8 9 10 public static void affiche( String s ) { System.out.println( s ); } public static void main( String[] arg ) { Test.affiche( "toto" ); // Ici je n'ai pas besoin de créer d'objet, je peux appeler la fonction statique directement depuis la classe elle même }
En comprenant ça, il parait donc évident qu'une méthode statique ne peut accéder uniquement qu'a une variable qui est aussi statique.

Or si tu regardes, la méthode main est une méthode statique (c'est comme ça tu peux rien y changer). C'est donc normal qu'elle ne puisse pas accéder aux attributs de ta classe CalculSimple (d'où la nécessite de passer tes attributs statique).

Le fait est que la méthode main est le point d'entré de ton programme, mais c'est une très mauvaise habitude que de coder directement à l’intérieur.

Le but c'est que ta méthode main ne soit là que pour instancier les objets de base et initialiser ton programme (et si on regarde bien, ta classe CalculSimple ne fait absolument rien, tout est dans le main). On peut y mettre plus de code, mais c'est toujours dans l'idée d’initialiser le reste de ton programme (récupérer des fichiers de conf par exemple).

Dans ton cas une solution pourrait être
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 66 67 public class CalculSimple { private JPanel fenetre; private JLabel label1; private JTextField nb1 = new JTextField( 10 ); private JLabel label2; private JTextField nb2; private JLabel label3; private JButton lancer; private JButton retirer; private JTextField resultat; public CalculSimple() { initComponents(); } private void initComponents() { JPanel fenetre = new JPanel(); JLabel label1 = new JLabel( "Nombre 1: " ); JTextField nb1 = new JTextField( 10 ); JLabel label2 = new JLabel( "Nombre 2: " ); JTextField nb2 = new JTextField( 10 ); JLabel label3 = new JLabel( "Résultat: " ); JTextField resultat = new JTextField( 10 ); JButton lancer = new JButton( "Ajouter" ); JButton retirer = new JButton( "Soustraire" ); GridLayout disposition = new GridLayout( 4, 2, 5, 5 ); //Grille de 4 lignes et 2 colonnes espacées de 5 dots fenetre.setLayout( disposition ); //on affecte la grille à la fenêtre //création des composants //Intégration des composants dans la fenêtre fenetre.add( label1 ); fenetre.add( nb1 ); fenetre.add( label2 ); fenetre.add( nb2 ); fenetre.add( label3 ); fenetre.add( resultat ); fenetre.add( lancer ); fenetre.add( retirer ); //Création d'un cadre et affectation à la fenêtre JFrame cadre = new JFrame( "Addition" ); cadre.setContentPane( fenetre ); cadre.setSize( 400, 150 ); cadre.setVisible( true ); //Affectation des listener aux boutons Moteur go = new Moteur( this ); //Moteur est la class qui gère les évènements lancer.addActionListener( go ); retirer.addActionListener( go ); } // Ici on ne fait que lancer la programme public static void main( String[] args ) { new CalculSimple(); }
Avec ce code il reste encore des problèmes de visibilité dans ta classe Moteur mais je te laisse les régler ;)

Cdt.

Bonjour Nico02

:roll: Oui je suis un peu confus de ne pas avoir suffisamment lu ta première réponse et j'en ai encore les fesses rouges!
Je dois cependant avouer que pour un débutant en programmation objet, ce n'est pas évident.
Il a fallu que je m'y prenne à plusieurs fois pour bien assimiler tes excellentes explications.
Voilà ce que j'en ai fait; merci de ta précieuse aide.

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
import javax.swing.*;
import java.awt.GridLayout;
 
public class CalculSimple {
	//déclaration des objets utilisés par la class Moteur
	public JTextField nb1 = new JTextField(10);
	public JTextField nb2 = new JTextField(10);
	public JTextField resultat = new JTextField(10);
 
	//Constructeur de la class
	private CalculSimple() {
		initComponents();
	}
	private void initComponents() {
		//Initialisation des objets
		JPanel fenetre = new JPanel();
		JLabel label1 = new JLabel("Nombre 1: "); 
		JLabel label2 = new JLabel("Nombre 2: "); 
		JLabel label3 = new JLabel("Résultat: ");
		JButton lancer = new JButton("Ajouter");
		JButton retirer = new JButton("Soustraire");		
		GridLayout disposition = new GridLayout(4,2,5,5); //Grille de 4 lignes et 2 colonnes espacées de 5 dots
		fenetre.setLayout(disposition);                   //on affecte la grille à la fenêtre	
		//Intégration des composants dans la fenêtre
		fenetre.add(label1);
		fenetre.add(nb1);
		fenetre.add(label2);
		fenetre.add(nb2);
		fenetre.add(label3);
		fenetre.add(resultat);
		fenetre.add(lancer);
		fenetre.add(retirer);
		//Création d'un cadre et affectation à la fenêtre
		JFrame cadre = new JFrame("Addition");
		cadre.setContentPane(fenetre);
		cadre.setSize(400,150);
		cadre.setVisible(true);
		Moteur go = new Moteur(this);
		//Affectation des listener aux boutons
		lancer.addActionListener(go);
		retirer.addActionListener(go);
	}
	public static void main(String[] args) {
		new CalculSimple();
	}
}

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
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import javax.swing.JOptionPane;
import javax.swing.JButton;
 
//Class qui est à l'écoute d'un évènement 
class Moteur implements ActionListener {
	CalculSimple calcul;  //Instance de la class CalculSimple
 
	//Fonction constructeur
	Moteur(CalculSimple calcul) {
		this.calcul = calcul; 
	}
 
	//Méthode utilisée dès qu'il y a un évènement
	public void actionPerformed(ActionEvent event){
		JButton touche = (JButton) event.getSource(); //touche est l'instance de l'objet qui a créé l'évènement
		String nTouche = touche.getText();            //nTouche est une variable contenant le texte de la touche indéxée
		//Fonction permettant d'afficher une boîte de dialogue
		JOptionPane.showMessageDialog(null,  "Action initialisée: " + nTouche,"Afficheur d'actions",JOptionPane.WARNING_MESSAGE);	
 
		//Opération
		int val1 =Integer.parseInt(calcul.nb1.getText());
		int val2 = Integer.parseInt(calcul.nb2.getText());
		if (nTouche == "Ajouter")
			calcul.resultat.setText(Integer.toString(val1 + val2));
		else
			calcul.resultat.setText(Integer.toString(val1 - val2));
	}
}