[Débutant] Création, appels et dispose() de Frames : conséquences mémoire ?
Bien le bonjour à tous !
Je travaille actuellement sur un projet en Java.
J'ai besoin d'afficher des messages d'erreurs en cas de levée d'exception, et j'ai donc utiliser le Visual Editor d'Eclipse pour me générer une petite classe de fenêtre. La voici :
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
| import javax.swing.JPanel;
import javax.swing.JFrame;
import javax.swing.BoxLayout;
import javax.swing.JTextPane;
import javax.swing.JSeparator;
import java.awt.Color;
import java.awt.Toolkit;
import java.awt.Font;
import javax.swing.WindowConstants;
public class Erreur extends JFrame {
private static final long serialVersionUID = 1L;
private JPanel jContentPane = null;
private JTextPane zone_excuse = null;
private JTextPane zone_detail = null;
private JTextPane zone_exception = null;
private JSeparator jSeparator = null;
private JSeparator jSeparator1 = null;
private JTextPane detail = null;
private JTextPane exception = null;
/**
* This is the default constructor
*/
public Erreur() {
super();
initialize();
}
/**
* This method initializes this
*
* @return void
*/
private void initialize() {
this.setSize(525, 220);
this.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
this.setIconImage(Toolkit.getDefaultToolkit().getImage(getClass().getResource("/Icones/Bayonne.png")));
this.setBackground(Color.white);
this.setContentPane(getJContentPane());
this.setTitle("ERREUR : Veilleur de messagerie");
}
/**
* This method initializes jContentPane
*
* @return javax.swing.JPanel
*/
private JPanel getJContentPane() {
if (jContentPane == null) {
jContentPane = new JPanel();
jContentPane.setLayout(new BoxLayout(getJContentPane(), BoxLayout.Y_AXIS));
jContentPane.add(getZone_excuse(), null);
jContentPane.add(getJSeparator(), null);
jContentPane.add(getDetail(), null);
jContentPane.add(getZone_detail(), null);
jContentPane.add(getJSeparator1(), null);
jContentPane.add(getException(), null);
jContentPane.add(getZone_exception(), null);
}
return jContentPane;
}
/**
* This method initializes zone_excuse
*
* @return javax.swing.JTextPane
*/
private JTextPane getZone_excuse() {
if (zone_excuse == null) {
zone_excuse = new JTextPane();
zone_excuse.setEditable(false);
zone_excuse.setText("Le veilleur de messagerie a rencontré une erreur critique. Veuillez nous excuser pour le dérangement occasionné par cette erreur.");
zone_excuse.setFont(new Font("Dialog", Font.BOLD, 12));
zone_excuse.setBackground(new Color(255, 255, 204));
}
return zone_excuse;
}
public void set_Zone_excuse_text(String new_value) {
zone_excuse.setText(new_value);
}
/**
* This method initializes zone_detail
*
* @return javax.swing.JTextPane
*/
private JTextPane getZone_detail() {
if (zone_detail == null) {
zone_detail = new JTextPane();
zone_detail.setEditable(false);
zone_detail.setFont(new Font("Dialog", Font.PLAIN, 10));
}
return zone_detail;
}
public void set_Zone_detail_text(String new_value) {
zone_detail.setText(new_value);
}
/**
* This method initializes zone_exception
*
* @return javax.swing.JTextPane
*/
private JTextPane getZone_exception() {
if (zone_exception == null) {
zone_exception = new JTextPane();
zone_exception.setEditable(false);
zone_exception.setFont(new Font("Dialog", Font.PLAIN, 10));
}
return zone_exception;
}
public void set_Zone_exception_text(String new_value) {
zone_exception.setText(new_value);
}
/**
* This method initializes jSeparator
*
* @return javax.swing.JSeparator
*/
private JSeparator getJSeparator() {
if (jSeparator == null) {
jSeparator = new JSeparator();
}
return jSeparator;
}
/**
* This method initializes jSeparator1
*
* @return javax.swing.JSeparator
*/
private JSeparator getJSeparator1() {
if (jSeparator1 == null) {
jSeparator1 = new JSeparator();
}
return jSeparator1;
}
/**
* This method initializes detail
*
* @return javax.swing.JTextPane
*/
private JTextPane getDetail() {
if (detail == null) {
detail = new JTextPane();
detail.setEditable(false);
detail.setFont(new Font("Dialog", Font.BOLD, 12));
detail.setText("Détails et solutions :");
}
return detail;
}
/**
* This method initializes exception
*
* @return javax.swing.JTextPane
*/
private JTextPane getException() {
if (exception == null) {
exception = new JTextPane();
exception.setEditable(false);
exception.setFont(new Font("Dialog", Font.BOLD, 12));
exception.setText("Message système à communiquer au service informatique :");
}
return exception;
}
} // @jve:decl-index=0:visual-constraint="10,10" |
Dans mon main(), je crée donc la fenêtre et je la masque via un dispose() pour libérer les ressources associées :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| public class Main
{
/*
* Lancement de l'application.
*/
public static void main(String[] args)
{
Erreur fenetre_erreur = new Erreur();
fenetre_erreur.setVisible(true);
//fenetre_erreur.dispose();
// Lancement de l'applicatif par la mise en place :
// - de l'icone en barre des tâches
// - de son menu, qui permet d'effectuer des tâches utilisateur
new Icone_et_Menu();
}
} |
Jusque là tout donctionne. C'est via mon "Icone_et_Menu()" que je ferai appel à des fonctions, grâce à des écouteurs sur mon menu. Pour ne pas embrouiller mon code, j'ai mes foncions dans un autre fichier.
Dans ces fonctions là, et plus précisément dans des "catch", je dois faire appel à ma fenetre d'erreur pour l'afficher et changer le texte des champs.
Mon soucis, evidemment, c'est que ma "fenetre_erreur" n'y est pas visible...
Comment faire ?
Dois-je forcément la passer en paramètre à mon applicatif, puis à mes fonctions ? Bien que le passage de paramètre se fasse par référence, ca me parait un peu lourd.
Une autre possibilité semblerait être de créer/disposer d'une nouvelle fenêtre à chaque fois qu'une exception est levée... Mais puisque cette application va rester en barre des tâches très longtemps (plusieurs jours eventuellement), est-ce que cette solution est viable sans alourdir la mémoire ? Est-ce que le dispose() est l'équivalant de la destruction de l'objet sur ce plan là ?
Merci pour vos conseils et vos remarques :-).
