Changer de titre JFrame ailleurs que constructeur

Version imprimable

Bonjour,

je suis autodidacte en Java ... et donc je comprend pas toujours tout :(
J'ai le code suivant et mon problème se situe dans la procédure Init() (Procédure mot venant du Basic ... en Java Méthode ?). Je passe par Init car dans mon projet je fais des calculs dedans que je n'ai pas envie de mettre dans le constructeur pour éviter de l'alourdir. Le code est en partie généré par WindowBuilder dans 'Eclipse. J'ai mis en commentaire les erreurs obtenues.
Comment donc changer le titre de mon JFrame hors constructeur.

Merci d'avance pour votre aide précieuse .....

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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
package gui;
 
import java.awt.EventQueue;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import javax.swing.JButton;
import javax.swing.UIManager;
import java.awt.GridBagLayout;
import java.awt.GridBagConstraints;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
 
public class PourForum extends JFrame {
 
	private JPanel contentPane;
	private JButton button;
	private static PourForum frame;
 
	/**
         * Launch the application.
         */
	public static void main(String[] args) {
		try {
			UIManager.setLookAndFeel("com.sun.java.swing.plaf.motif.MotifLookAndFeel");
		} catch (Throwable e) {
			e.printStackTrace();
		}
		EventQueue.invokeLater(new Runnable() {
			public void run() {
				try {
					frame = new PourForum();
					frame.setVisible(true);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		});
	}
 
	/**
         * Create the frame.
         */
	public PourForum() {
		setTitle("Titre 1");
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setBounds(100, 100, 621, 428);
		contentPane = new JPanel();
		contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
		setContentPane(contentPane);
		GridBagLayout gbl_contentPane = new GridBagLayout();
		gbl_contentPane.columnWidths = new int[]{0, 0, 0};
		gbl_contentPane.rowHeights = new int[]{0, 0, 0};
		gbl_contentPane.columnWeights = new double[]{0.0, 0.0, Double.MIN_VALUE};
		gbl_contentPane.rowWeights = new double[]{0.0, 0.0, Double.MIN_VALUE};
		contentPane.setLayout(gbl_contentPane);
 
		button = new JButton("Rendre invisible");
		button.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent arg0) {
				button_ferme();
 
			}
		});
		GridBagConstraints gbc_button = new GridBagConstraints();
		gbc_button.gridx = 1;
		gbc_button.gridy = 1;
		contentPane.add(button, gbc_button);
 
		init();
 
	}
 
	static void button_ferme() {
		frame.setVisible(false); 
 
		frame.setVisible(true);                    // sert pour test uniquement
	}
 
 
	static void init() {
		setTitle("Titre 2");					// Réponse Eclipse: Cannot make a static reference to the non-static method setTitle(String) from the type Frame
		frame.setTitle("Titre 2"); 				// Pas d'erreur à la compilation mais à l'éexécution:
												/*	java.lang.NullPointerException
															at gui.PourForum.init(PourForum.java:87)
															at gui.PourForum.<init>(PourForum.java:74) */
		this.setTitle("Titre 2");				// Réponse Eclipse: Cannot use this in a static context
	}
}

22/05/2016, 12h03
Cafeinoman

Pourquoi tant de static? Enleve le static sur ta methode init, il n'a pas de raison d'être.

Salut,
Code:

setTitle("Titre 2"); // Réponse Eclipse: Cannot make a static reference to the non-static method setTitle(String) from the type Frame

Une méthode static est commune à toutes les instances : elle n'a donc pas accès à une instance particulière, et donc ne saurait accèder à une méthode d'instance.
Code:

1 2 3 4 frame.setTitle("Titre 2"); // Pas d'erreur à la compilation mais à l'éexécution: /* java.lang.NullPointerException at gui.PourForum.init(PourForum.java:87) at gui.PourForum.<init>(PourForum.java:74) */
Lors de l'appel frame = new PourForum();, la construction de PourForum() est exécutée complètement, puis frame est affectée avec la référence de l'instance ainsi créée. Lors de l'exécution du constructeur, donc, la variable n'est pas encore affectée, donc null, d'où la NullPointerException (init() étant appelée dans le constructeur).
Code:

1 2 this.setTitle("Titre 2"); // Réponse Eclipse: Cannot use this in a static context
Une méthode static est commune à toutes les instances : this représente une instance (celle dans laquelle le this est invoqué), donc il n'est pas possible d'utiliser this dans une méthode static car on ne sait pas quelle instance ça pourrait représenter.
Le premier choix est une solution, mais, comme dit Cafeinoman, dans une méthode non static. Lors de l'appel, il faudra avoir la référence de la fenêtre. La troisième également, dans le même cadre, car elle serait équivalente.
Le second choix est une solution, mais elle ne pourra être appelée qu'après l'affectation : comme l'affectation est faite dans l'Event Dispatch Thread, tu pourras l'appeler dans n'importe quelle méthode s'éxécutant dans l'Event Dispatch Thread. Dans les autres méthodes, dans le cas générale ça fonctionnera aussi, parce que l'exécution de la construction sera très rapide, et il y a peu de probabilité que la variable ne soit pas déjà affectée dans l'exécution d'un code ultérieure, mais c'est possible, donc l'application risque de planter de manière aléatoire, ce qu'il faut absolument éviter. La solution serait ne pas exécuter la construction dans l'Event Dispatch Thread, d'autant que ce n'est pas nécessaire, justement parce que tant que la première fenêtre n'est pas créée, il n'y a pas de risque de conflit dans ton cas.

A noter que pour fermer définitivement une fenêtre on appelle dispose(). L'appel de setVisible(false) ne fait que la cacher (la rendre invisible).

22/05/2016, 13h19
Gpaque

Un tout grand merci à tous les deux.
Joël, j'avoue ne pas avoir tout compris dans les moindre détails .... mis ça me fut bien utile ... merci beaucoup.
J'avoue que je ne sais jamais quand je doit mettre static ou non ? C'est la partie de Java que je ne maitrise pas du tout.
Bonne journée à tous.
22/05/2016, 13h25
joel.drigo

Citation:

Envoyé par Gpaque

Joël, j'avoue ne pas avoir tout compris dans les moindre détails .... mis ça me fut bien utile ... merci beaucoup.

N'hésite pas à poser les questions sur les points que tu ne comprends pas.
24/05/2016, 15h03
Gpaque

Merci Joël pour ta proposition .... en plus tu as l'air pédagogue :mouarf::

Ma question est simple (mais je pense que ce n'est plus sa place).
J'ai des difficulté avec static. Je ne sais jamais quand je dois le mettre. A quoi ça correspond ...
C'est quoi un variable static et une méthode static .....
Merci de ton aide.

Bonne journée

Globalement
Une variable static est une variable dont la valeur est la même pour toutes les instances d'un objet d'une même classe. Une méthode statique c'est une méthode qui n'agit pas sur l'instance d'une classe.
Déjà, il faut définir ce qu'est une instance.
Prenons une classe par exemple :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 public class Ami { private String prenom; public Ami(String prenom) { this.prenom=prenom; } public String getPrenom() { return prenom; } }
Cette classe définit une "chose". Ici, elle définit un Ami, en disant qu'un Ami a un attribut prenom. On peut créer plusieurs instances de Ami :
Code:

1 2 3 4 5 6 7 8 9 10 public class Test { public static void main(String[] args) { // oublie qu'il y a static ici pour le moment : dis-toi que c'est juste le "nom complet" que doit avoir cette méthode pour exécuter le programme, point. // je créé une instance de Ami, et je stocke sa référence dans la variable ami1, pour pouvoir la manipuler Ami ami1 = new Ami("Paul"); // je créé une autre instance de Ami, et je stocke sa référence dans la variable ami2, pour pouvoir la manipuler Ami ami2 = new Ami("Virginie"); } }
Ainsi, j'ai 2 instances de classe Ami : 2 amis différents, qui ont chacun un prénom, différent, Paul pour l'une et Virginie pour l'autre.
Un attribut non static est propre à chaque instance.
Maintenant, si je modifie ma classe, en ajoutant un attribut "groupe (ou chanteur) de musique préféré":
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 public class Ami { private String prenom; private String groupe; public Ami(String prenom) { this.prenom=prenom; } public String getPrenom() { return prenom; } public void setGroupePrefere(String groupe) { this.groupe=groupe; } public String getGrouperPrefere() { return groupe;: } }
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 public class Test { public static void main(String[] args) { // oublie qu'il y a static ici pour le moment : dis-toi que c'est juste le "nom complet" que doit avoir cette méthode pour exécuter le programme, point. // je créé une instance de Ami, et je stocke sa référence dans la variable ami1, pour pouvoir la manipuler Ami ami1 = new Ami("Paul"); // je créé une autre instance de Ami, et je stocke sa référence dans la variable ami2, pour pouvoir la manipuler Ami ami2 = new Ami("Virginie"); ami1.setGroupePrefere("Major Lazer"); // on affecte à ami1 le groupe Major Lazer ami2.setGroupePrefere("Jefferson Airplane"); // on affecte à ami2 le groupe Jefferson Airplane } }
Le groupePrefere est une variable d'instance : chaque ami a groupe différent. Si je change le groupe de ami1 en "Parov Stelar", le groupe de ami2 ne change pas.
Une variable statique est commune à toutes les instances
Maintenant je change ma classe comme ça, en ajoutant une variable static nombreamis
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 public class Ami { private static int nombreamis; private String prenom; public Ami(String prenom) { nombreamsi++; this.prenom=prenom; } public String getPrenom() { return prenom; } public static int getNombreAmis() { return nombreamis; } public String toString() { return prenom + " (" + nombreamis +")"; } }
Lorsque je fais

Code:

Ami ami1 = new Ami("Paul");

nombreamis est incrémenté : si je fais tout de suite après :

Code:

System.out.println( ami1 );

On obtient :

Citation:

Paul (1)

Ensuite, on fait :

Code:

Ami ami2 = new Ami("Virginie");

nombreamis est incrémenté : si je fais tout de suite après :

Code:

System.out.println( ami2 );

On obtient :

Citation:

Virginie (2)

Si on fait de nouveau

Code:

System.out.println( ami1 );

juste après, on obtient :

Citation:

Paul (2)

La valeur de la variable nombreamis est la même pour toutes les instances : si elle vaut 2 pour Virgine, elle vaut 2 aussi pour Paul, et réciproquement.
Méthode statique
Une méthode statique est une méthode qui n'a pas accès aux variables d'instances : comme la variable static, elle est commune à toutes les instances. D'ailleurs, par convention, on ne l'appellera jamais sur une instance, mais sur la classe directement :
Code:

1 2 3 4 5 Ami ami1 = new Ami("Paul"); Ami ami2 = new Ami("Virginie"); System.out.println("Le nombre d'amis créés est : "+ Ami.getNombreAmis())
Quand utiliser static et ne pas utiliser static.
Pour les variables, j'aurais tendance à dire que tant que tu te poses la question sans pouvoir y répondre facilement ou rapidement, alors la réponse est "pas static". Malgré le fait que dans certains cas, ça peut être complexe de ne pas utiliser de statique (ou disons que c'est simplistement plus facile de céder à la tentation de faire une statique), dans la majeure partie des cas, se passer de variables static est encore la meilleure façon de ne pas se planter. Le truc, c'est qu'en plus ça permet de prendre une bonne habitude : lorsqu'on sait immédiatement dire si une variable doit être statique ou pas, alors on ne fait quasiment jamais de variables statiques, voire on n'en fait pas. Ce qui permet d'avoir des programmes beaucoup plus souples, des classes mieux réutilisables, dans différents contextes, etc. Sauf exceptions (il y en a toujours) :
Le cas de ce qu'on appelle souvent constante : la static final. Elle permet lorsqu'on a besoin d'utiliser une valeur qui ne va pas varier durant l'exécution du programme, de définir cette valeur à un seul endroit, ce qui sera plus facile par la suite si on veut modifier le truc.
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 public class Ami { public static final String GROUPE_PAR_DEFAUT = "Aucun"; private String prenom; private String groupe; public Ami(String prenom) { this.prenom=prenom; this.groupe=GROUPE_PAR_DEFAUT; } public String getPrenom() { return prenom; } public void setGroupePrefere(String groupe) { this.groupe=groupe; } public String getGrouperPrefere() { return groupe;: } }
Si tu veux pouvoir tester dans une partie de ton programme que le groupe est le groupe par défaut :
Code:

1 2 3 if ( Ami.GROUPE_PAR_DEFAUT.equals(amitruc.getGroupePrefere()) { // amitruc n'a pas encore de groupe de musique préféré... }
On aurait pu mettre directement la chaîne, mais si jamais on la change, il faudrait la changer partout, alors qu'avec la static final, on la change qu'à un seul endroit. Si en plus la chaîne est longue et compliquée, ça évite de se prendre la tête à cause d'une simple erreur de frappe, parce qu'on a taper d'un côté "Supercalifragilisticexpialidocious" et de l'autre "Supercalifragilsticexpialidocious" et qu'on ne comprend pas pourquoi cette satanée égalité dit que ce n'est pas égal !

Bon, là, dans mon premier exemple, c'est pour l'exemple : si par hasard il existe un groupe de musique qui s'appelle "Aucun", on sera pas bien embêté ;)

Tu remarqueras que j'ai utilisé des majuscules pour le nom de la static final : c'est une convention, justement, pour qu'on repère plus vite ces constantes.
D'autres cas que tu as l'occasion de voir quand tu seras plus avancé en Java
Le cas des méthodes statiques
Le cas particulier de la méthode main(String[] args) : elle est static, parce que c'est la méthode que Java va appeler pour lancer un programme. Et on ne veut pas se compliquer la vie avec une instance à créer, parce que si c'était le cas, on pourrait avoir des valeurs à passer au constructeur, et donc tout un truc pour le faire. Il y a d'autre avantage à ce qu'on ait une méthode dont on peut être sûr, à moins de faire n'importe quoi, qu'elle s'exécutera un minium (pour faire une gestion propre des erreurs le cas échéant).
Le cas des méthodes utilitaires : ce sont des méthodes indépendantes, qu'on veut pouvoir utiliser à différents endroit dans le programme, et qui n'appartiennent pas à une classe ni à une instance. On les mets dans une classe particulière. Par exemple, ici, un méthode qu'on veut utiliser pour nettoyer la saisie de prénom des espaces superflues :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 public class MesUtils { public static String supprimeEspacesSuperflues(String prenom) { if ( prenom==null ) { return null; } else { return prenom.trim().replaceAll("\\s+", " "); } } }
On ne fera jamais de new MesUtils(). On appellera MesUtils.supprimeEspcacesSuperflues( saisie)
Parfois, une méthode statique peut faciliter les échanges entre instances. Particulièrement, par exemple, pour l'UI. Tu verras plus tard quand tu seras plus avancé en Java et en POO, la notion de singleton.
Exemple :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 public class MonProgramme { private static JFrame mainFrame; public static void main(String[] args) { mainFrame = new JFrame("Mon application"); mainFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); mainFrame.add( new MainPanel() ); mainFrame.setSize(600,400); mainFrame.setLocaltionRelativeTo(null); mainFrame.setVisible(true); } public static JFrame getMainFrame() { return mainFrame; } }
Ce sera bien pratique que les autres classes de ton programme (comme MainPanel par exemple) puisse accèder à la fenêtre principale par MonProgramme.getMainFrame();
Les autres cas : idem, que pour les variables. Tant que tu te poseras la question sans trouver facilement la réponse, alors la réponse sera : ne pas faire de static.
Si jamais tu as dans une de tes classes une variable ou une méthode static, c'est qu'il y a probablement un problème quelque part, de conception.
En résumé :

en commun à toutes les instances :arrow: static, sinon pas static
tu ne sais pas trop et ce n'est pas évident pour toi de le savoir, tu y as déjà réfléchi depuis plus de 30 sec :arrow: pas static

Salut,

Une variable (ou méthode) static est une variable (ou méthode) qui est commune à toutes les instances de cette classe. Il n'est donc pas nécessaire d'avoir une instance de cette classe pour pouvoir y accéder.

C'est très pratique pour définir des constantes par exemple.

Exemple:
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 public class Test { public static String staticVar; // variable statique. private String var; // Constructeur public Test( String value ){ staticVar = value; var = value; } // Getter de la variable non statique public String getStaticValue(){ return staticVar; } // Getter de la variable statique public String getValue(){ return var; } // Petit code de test public static final main( String[] args ) { Test t1 = new Test( "Bonjour" ); // On crée des instance de la classe Test Test t2 = new Test( "Salut" ); Test t3 = new Test( "Aurevoir" ); System.out.println( t1.getValue() ); // donne "Bonjour" System.out.println( t2.getValue() ); // donne "Salut" System.out.println( t3.getValue() ); // donne "Aurevoir" System.out.println( t1.getStaticValue() ); // donne "Aurevoir" System.out.println( t2.getStaticValue() ); // donne "Aurevoir" System.out.println( t3.getStaticValue() ); // donne "Aurevoir" } }
On voit bien ici que chaque instance de la classe Test a une variable qui lui est propre et le fait de modifier cette valeur sur une instance en particulier n'a pas d'impact sur la valeur des autres instances.

Par contre on voit que s'est exactement l'inverse pour la variable statique. Comme elle est commune à toutes les instances, si l'une d'elle modifie la valeur, alors les autres verront aussi cette modification.

On peut aussi accéder directement à cette valeur sans avoir besoin d'une instance en utilisant directement le nom de la classe. C'est d’ailleurs tout l’intérêt.
Code:

1 2 System.out.println( Test.staticVar );
C'est le même principe pour les méthodes. Cela permet de définir des comportements commun à tes objets. C'est très utile pour définir des classes utilitaire par exemple.

Exemple dans un cas simple avec une fonction d'addition.
Code:

1 2 3 4 5 6 7 8 9 public class MaClasseDeMath{ public static add( int a, int b ){ return a + b; } } System.out.println( MaClasseDeMath.add( 1, 2 ) ); // Donnera 3
Voila n'hésite pas si tu as d'autres questions,

Cdt.

edit: grillé :aie:

26/05/2016, 21h19
Gpaque

Citation:

Envoyé par joel.drigo

.....

Merci Joël, tu es très pédagogue, car j'ai compris .... et pourtant tu n'es pas le premier à me fournir des explications ..
Merci beaucoup, surtout que la réponse a due te prendre un certain temps ....
26/05/2016, 21h20
Gpaque

Citation:

Envoyé par Nico02

.....

Merci Nico, tes exemples m'ont permis de voir si j'avais bien compris les informations de Joël ....