Discussion :

[NuageDeLait]

Bonjour à tous,

Après une longue période d'hibernation, je me suis dit tiens, java ? comment ça marche ? et là... c'est le drame.

J'ai lu plusieurs tuto, fait des recherches internet, mais je n'arrive pas à avancer.

Pour faire simple (j'adore quand c'est simple), je voudrai définir une fenêtre contenant des zones ou viendront au cours du programme afficher l'évolution des valeurs des variables. Mon petit programme le fait... : affichenbrepossibilite.setText("nombre de possibilite : " + nbrepossibilite );

sauf que j'aimerai mettre à jour ces valeurs depuis n'importe ou dans le programme, par exemple depuis un sous-programme qui doit tourner "très longtemps" : TestPossibilite();

voici mon piètre code :

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
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
import java.awt.* ; import javax.swing.* ;
 
public class Test{
 
	public static int nbrepossibilite = 0;
 
	public static void main(String args[]) {
 
	JFrame f = new JFrame ("Etat en cours");	
	f.setSize (400, 400);
	f.setVisible (true);
	//pas de disposition auto
	f.setLayout(null);
	Container contentpane = f.getContentPane();
 
	JLabel affichenbrepossibilite = new JLabel ();
	affichenbrepossibilite.setBounds(10,100,250,20);
	affichenbrepossibilite.setBackground(Color.WHITE);
	affichenbrepossibilite.setOpaque(true);
	contentpane.add (affichenbrepossibilite);
 
	Ini();
 
 
	TestPossibilite();
 
	affichenbrepossibilite.setText("nombre de possibilite : " + nbrepossibilite );
 
 
	// Quitte le programme lorsque la fenêtre est fermée
	f.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);
	}	
 
 
	static void TestPossibilite() {
 
		nbrepossibilite++;
 
		//partie qui ne fonctionne pas à cet endroit
		affichenbrepossibilite.setText("nombre de possibilite : " + nbrepossibilite );
 
	}
 
 
	static void Ini() {
 
		nbrepossibilite=0;
 
	}
 
}

Merci de votre aide et de votre clairvoyance.

NuageDeLait

[joel.drigo]

Salut,

toute variable que tu veux manipuler (modifier ou consulter) doit être exister et visible dans le scope du code qui fait cette manipulation.

ici tu manipule ta variable affichenbrepossibilite dans la méthode TestPossibilite

alors qu'elle est déclarée dans ta méthode main. elle est donc locale à cette méthode et donc invisible en dehors de cette méthode.

2 solutions :
- passer cette variable en argument de ta méthode TestPossibilite, cet argument étant visible dans le scope de TestPossibilité

- soit déclarer cette variable en tant que variable membre de ta classe Test, en static bien sur parce que tes méthodes qui la manipulent sont statiques

[NuageDeLait]

Bonjour et merci de ton aide.

Excuse ces propos crus, mais je ne comprend pas ta réponse.

affichenbrepossibilite n'est pas une variable ou alors je n'ai vraiment rien compris à java. C'est un objet ? qui représente un jlabel que j'ai défini effectivement dans mon main (c'est peut être là mon erreur d’ailleurs ?).

Ma variable, c'est nbrepossibilite, qui est accessible partout.
System.out.println(nbrepossibilite); fonctionne dans TestPossibilité()

Tant que je fais un settext dans main, je peux remplir cet objet. Mais, si je veux le faire depuis un sous-programme, il m'indique l'erreur comme quoi il ne peut pas être résolu (même si le contenu est un simple texte : affichenbrepossibilite.setText("nombre de possibilite" ); par exemple.

Je voudrai avoir quelque chose de bien séparé, d'un côté mon affichage, de l'autre mes calculs. J'avais bien pensé faire un sous programme fenêtre avec passage de variables à afficher, mais dans ce cas, la définition : JLabel affichenbrepossibilite = new JLabel (); je la case ou ?

[joel.drigo]

affichenbrepossibilite est bien une variable qui référence une instance d'objet (de classe JLabel).

Une variable a un type : quand tu déclares ta variable tu indiques le type qui sera utilisé par le compilateur pour manipuler ta variable :

Code :

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

1
2
3
4
public class Test {
    ...
 
    private static JLabel affichenbrepossibilite;

...
[/CODE]

quand tu instancies ton objet tu écris ce qui suit, ce qui constitue en une affectation de ta variable avec une référence sur l'instance d'objet créé

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
public class Test {
 
    ...
 
    public static void main(String args[]) {
 
       ...
 
      affichenbrepossibilite = new JLabel ();
 
       ...
 
    }
 
}

on aurait pu tout aussi bien déclaré la variable comme suit :

Code :

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

1
2
3
4
5
6
public class Test {
    ...
 
    private static Object affichenbrepossibilite;
 
    ...

mais à chaque fois qu'on aurait manipuler cette variable en tant que référence sur un objet de classe JLabel, il aurait fallut l'indiquer au compilateur en la castant en JLabel

si tu as une erreur avec

Code :

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

1
2
3
4
5
6
7
8
static void TestPossibilite() {
 
		nbrepossibilite++;
 
		//partie qui ne fonctionne pas à cet endroit
		affichenbrepossibilite.setText("nombre de possibilite : " + nbrepossibilite );
 
	}

c'est parce que la variable affichenbrepossibilite n'existe pas dans le scope de ta méthode.

tu peux la déclarer dans ta méthode TestPossibilite, mais dans ce cas ce sera une autre variable (de même nom) que celle créée dans ta méthode main.

Le fait d'en déclarer une dans le scope statique de ta classe (bien sûr ici c'est un snippet, dans le cas d'un vrai programme, on la déclarait plutôt membre et on construirait la fenêtre (JFrame) dans une méthode non statique d'une classe dédiée à la gestion de cette fenêtre (étendant JFrame par exemple), te permet de l'instancier ton objet dans une méthode (main) et de la manipuler (appeler sa méthode setText(...) en l'occurence) dans une autre, en utilisant la même variable dans les deux méthodes

Dans la méthode ou l'objet est instancié, on affecte sa référence à la variable, pour que lors de sa manipulation dans l'autre méthode (TestPossibilite)) soit possible.
tant que tu ne changes pas la valeur de la variable entre les deux, la variable permet bien de manipuler la même instance d'objet.

L'appel de la méthode setText sur ta variable affichenbrepossibilite créée dans Main est possible par contre parce qu'on est toujours dans la méthode main : on affecte la variable et on appelle la méthode de la classe de l'objet référencé par la variable dans le même scope (le même bloc en l'occurence)

j'ai utilisé volontairement un langage verbeux pour bien que tu comprennes les différentes notions manipulées.

on à l'habitude à l'usage de mélanger variable, objet, instance, classe en disant tu modifie le texte de affichenbrepossibilite dans Main, ce qui est une façon abrégée de dire :
tu appelles la méthode setText de la classe JLabel, classe de l'instance d'objet référencé par la variable affichenbrepossibilite, variable locale au bloc principal de le ta méthode main

dans le code suivant tu aurais un NullPointerException lors de l'appel de setText :

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

        JLabel afficherepossibilite = null;

        if  ( args.length>0 ) {
        JLabel affichenbrepossibilite = new JLabel ();
	affichenbrepossibilite.setBounds(10,100,250,20);
	affichenbrepossibilite.setBackground(Color.WHITE);
	affichenbrepossibilite.setOpaque(true);
	contentpane.add (affichenbrepossibilite);
        }
 
	Ini();
 
 
	TestPossibilite();
 
	affichenbrepossibilite.setText("nombre de possibilite : " + nbrepossibilite );

les variables en orange et en bleu ont le même nom, mais n'existent pas dans le même scope (donc elles ont droit d'avoir le même nom), mais ce sont pas les mêmes variables : si tu modifies la valeur de l'une, l'autre ne sera pas modifiée.

à l'inverse si tu écris

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
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class Test{
 
       ...
 
	public static void main(String args[]) {
 
	...
 
        JLabel affichenbrepossibilite = new JLabel ();
 
	 ...
 
	TestPossibilite(affichenbrepossibilite);
 
 
 
	// Quitte le programme lorsque la fenêtre est fermée
	f.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);
	}	
 
 
	static void TestPossibilite(JLabel label) {
 
		nbrepossibilite++;
 
		...
		label.setText("nombre de possibilite : " + nbrepossibilite );
 
	}
 
 
	...
 
}

tu as deux variables de 2 scopes différents (l'une affichenbrepossibilite dans le bloc principal de la méthode main et l'autre label dans le scope de ta méthode TestPossibilite), mais comme label est un argument de TestPossibilite, la valeur contenue dans affichenbrepossibilite (qui est la référence de l'instance d'objet JLabel créée dans main)) est passée lors de l'appel de la méthode et est transmise dans la méthode TestPossibilite à la variable label

label a pour valeur donc la référence à la même instance de classe JLabel (donc celle qui s'affiche dans ta jframe), donc quand on appelle la méthode setText sur cette instance dans la méthode TestPossibilite, on modifie bien l'état de cette même instance

[NuageDeLait]

Après avoir relu plusieurs fois ton message, plusieurs constatations s'imposent :

1. ta patience est grande ainsi que ta verbosité
2. la logique de java m’échappe un peu (et c'est rien de le dire)
3. c'est vraiment compliqué pour faire une chose aussi élémentaire.

Bon, maintenant, cela fonctionne effectivement avec ce code :

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
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
import java.awt.* ; import javax.swing.* ;
 
public class Test{
 
	public static JLabel affichenbrepossibilite;
	public static int nbrepossibilite = 0;
 
	public static void main(String args[]) {
 
	JFrame f = new JFrame ("Etat en cours");	
	f.setSize (400, 400);
	f.setVisible (true);
	//pas de disposition auto
	f.setLayout(null);
	Container contentpane = f.getContentPane();
 
	//création du champ dans la fenetre	
	JLabel affichenbrepossibilite = new JLabel ();
	affichenbrepossibilite.setBounds(10,100,250,20);
	affichenbrepossibilite.setBackground(Color.WHITE);
	affichenbrepossibilite.setOpaque(true);
	contentpane.add (affichenbrepossibilite);
 
 
	Ini();
	nbrepossibilite++;
	affichenbrepossibilite.setText("nombre de possibilite : " + nbrepossibilite );
	TestPossibilite(affichenbrepossibilite);
 
	//affichenbrepossibilite.setText("nombre de possibilite : " + nbrepossibilite );
 
	// Quitte le programme lorsque la fenêtre est fermée
	f.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);
	}	
 
	static void TestPossibilite(JLabel label) {
 
		nbrepossibilite++;
		label.setText("nombre de possibilite : " + nbrepossibilite );
	}
 
 
	static void Ini() {
		nbrepossibilite=0;	
	}
 
}

Mais, mais, mais comme ma fenêtre devra afficher pas mal de variables... ce passage de paramètres/object ne me semble pas adaptée. Je vais donc creuser la question.

Grand merci pour le coup de main. Je repart mais le chemin vient de m’apparaitre du coup beaucoup plus long.

NuageDeLait

[joel.drigo]

1. ta patience est grande ainsi que ta verbosité

en informatique et en particulier en programmation, les choses se doivent d'être précises et exactes. à partir du moment ou on comprend, on peut se permettre les approximations, car on comprend ce qu'elles cachent; Trop souvent des apprentis informaticiens utilisent sans le savoir des approximations qui finissent un jour par poser problème (ça me rappelle un ingénieur débutant qui pensait que tout chemin d'accès à un fichier commençait par une lettre suivi de deux-points et qui n'avait jamais entendu parlé d'url)

2. la logique de java m’échappe un peu (et c'est rien de le dire)

c'est pourtant la logique de la plupart des langages objets, et la manipulation de variables de java est identique, ou du moins similaire, à la plupart des langages structurés

3. c'est vraiment compliqué pour faire une chose aussi élémentaire.

y'a rien de compliqué la dedans. d'ailleurs y'a jamais rien de compliqué en programmation. il peut y avoir des choses complexes certes.
en l’occurrence, avoir la référence de instance dont on veut appeler une méthode est le b-a-ba, je vois pas trop comment on pourrait faire autrement.