Passer une variable à un JLabel

Version imprimable

Bonjour,
je debute juste en java, j'ai acheté un livre de Anne Tasso, mais je galère
ce que je voulais faire, c'est
- calculer une différence de date (ça c'est OK)
- ouvrir une fenetre
inclure un JLabel qui me dit le resultat (ma variable s'appelle long depuis)
après quarante douze mille essais j'y suis parvenu, mais mon programme me semble complètement déstructuré.
pourriez vous m'aider dans l'organisation pour que depuis le main je puisse modifier le contenu d'un JLabel et dans l'organisation en général de la structure de mon prog pour eviter les envois de variables redondants aux fonctions et aux class
pour info, voici mon (hum) magnifique (hum hum !...) code

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
 
import javax.swing.*;
 
import java.awt.FlowLayout;
import java.awt.event.*;
import java.util.Date;
import java.util.GregorianCalendar;
 
public class MonApplication {
	static long depuis;
 
  public static void main(String[] args) {
	 // MaFenetre f = new MaFenetre(depuis);
 
    /** La date du départ*/
 
	  int anneeLMK = 2015, moisLMK = 03,jourLMK = 27;//27/03/2015 dernier post
	  Date date1 = new GregorianCalendar(anneeLMK,moisLMK-1,jourLMK,15,11).getTime( );
/** je peux mettre annee + mois+jour+heure+minutes
ou seulement annee + mois+jour, attention mois = mois-1*/
    /** Date du jour */
    Date today = new Date( );
 
    // Calcul de différence
    long diff = today.getTime( ) - date1.getTime( );
 
    System.out.println("La différence en nombre de jour entre \n"+date1+ " \net \n " + today +
            " \nest : " + (diff / (1000*60*60*24)) + " jours.");
    depuis = (diff / (1000*60*60*24));
    MaFenetre f = new MaFenetre(depuis);
    if (diff / (1000*60*60*24) > 9){
    	f.afficher(depuis);
    }
    }	
 
}
 
class MaFenetre {
 
  JFrame mainFrame = null;
 
  public MaFenetre(long depuis) {
 
	mainFrame = new JFrame();
    mainFrame.setTitle("Depot de titre sur LMK a faire");
    mainFrame.setSize(320, 240);
    mainFrame.setContentPane(buildContentPane(depuis));
 
    mainFrame.addWindowListener (new WindowAdapter() {
      public void windowClosing(WindowEvent ev) {
        System.exit(0);
      }
 
    });
 
 
 
  }
 
  public JPanel buildContentPane(long depuis){
		JPanel panel = new JPanel();
		panel.setLayout(new FlowLayout());
		String text = ("coucou "+depuis);
		JLabel label = new JLabel(text);
 
		panel.add(label);
 
		return panel;
	}	
 
  public void afficher(long diff) {
	  mainFrame.setTitle("pas déposé sur LMK depuis "+diff/ (1000*60*60*24) + " jours");
 
 
    mainFrame.setVisible(true);
  }
}

merci à vous

Salut,

Ce n'est pas si mal que ça. A part la variable statique qu'il faut toujours éviter à tout prix.

On pourrait un peu réorganiser comme ça :

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
public class MonApplication {
 
	public static void main(String[] args) {
 
		/** La date du départ */
 
		int anneeLMK = 2015; // évite en général de déclarer plusieurs variables sur la même ligne, ça peut amener de la confusion et des erreurs difficiles à repérer, et c'est aussi plus souple pour les modifications
		// int moisLMK = 3; // évite de mettre 0 devant une valeur entière : ceci à une signification en Java. ça signifie que le nombre est en octal : pour un entier inférieur à 8 ça ne change rien, mais si tu avais eu besoin de faire le mois de septembre, 09 n'aurait pas fonctionner
		int moisLMK = Calendar.MARCH; // c'est encore mieux en utilisant la constante : là, tu es sûr que c'est la bonne valeur (pas besoin de faire -1)
		int jourLMK = 27;// 27/03/2015 dernier post
 
		Date date1 = new GregorianCalendar(anneeLMK, moisLMK, jourLMK, 15, 11)
				.getTime();
 
		/**
                 * je peux mettre annee + mois+jour+heure+minutes ou seulement annee +
                 * mois+jour, attention mois = mois-1
                 */
		/** Date du jour */
		Date today = new Date();
 
		// Calcul de différence
		long diff = today.getTime() - date1.getTime(); // attention à ce genre de différence (voir exemple dans l'autre code)
 
		long depuis = diff / (1000 * 60 * 60 * 24); // éviter de refaire le calcul plusieurs fois
 
		System.out.println("La différence en nombre de jour entre \n" + date1
				+ " \net \n " + today + " \nest : " + depuis + " jours.");
 
		if (depuis > 9) { // on créer la fenêtre que si nécessaire
			MaFenetre f = new MaFenetre(depuis);
			f.setSize(320, 240); // on dimensionne la fenêtre au besoin (on ne force pas la fenêtre à avoir une taille en mettant ça dans la classe).
			f.setLocationRelativeTo(null); // on centre la fenêtre
			f.setVisible(true); // préférer un affichage externe, ce qui permet de modifier le comportement de la classe d'origine
		}
	}
 
	// préférer une classe statique interne privée à une classe privée (qu'on utilise pour des petits tests temporaires éventuellement)
    private static class MaFenetre extends JFrame { // si la classe étend JFrame, inutile d'avoir une variable interne
 
		public MaFenetre(long depuis) {
 
			setTitle("pas déposé sur LMK depuis " + depuis + " jours");
 
			setContentPane(buildContentPane(depuis));
 
			setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // évite d'avoir à écrire soit-même un WindowAdapter qui fait un exit(0)
 
		}
 
		private JPanel buildContentPane(long depuis) { // la méthode n'a pas besoin d'être public : ça ne sert à rien de l'appeler de l'extérieur
			JPanel panel = new JPanel();
			// panel.setLayout(new FlowLayout()); // inutile : 
			String text = ("coucou " + depuis);
			JLabel label = new JLabel(text);
 
			panel.add(label);
 
			return panel;
		}
 
	}
 
}

En Java 8 (avec l'API java.time) :

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
public class MonApplication {
 
	public static void main(String[] args) {
 
		/** La date du départ */
 
		int anneeLMK = 2015; // évite en général de déclarer plusieurs variables sur la même ligne, ça peut amener de la confusion et des erreurs difficiles à repérer, et c'est aussi plus souple pour les modifications
		// int moisLMK = 3; // évite de mettre 0 devant une valeur entière : ceci à une signification en Java. ça signifie que le nombre est en octal : pour un entier inférieur à 8 ça ne change rien, mais si tu avais eu besoin de faire le mois de septembre, 09 n'aurait pas fonctionner
		Month moisLMK = Month.MARCH; // c'est encore mieux en utilisant la constante : là, tu es sûr que c'est la bonne valeur (pas besoin de faire -1)
		int jourLMK = 27;// 27/03/2015 dernier post
 
		LocalDateTime date1 = LocalDateTime.of(anneeLMK, moisLMK, jourLMK, 15, 11);
 
		LocalDateTime today = LocalDateTime.now();
 
		// Calcul de différence
 
		// dans ce cas la différence est en jour plein
		/*Period difference = Period.between(date1.toLocalDate(), today.toLocalDate());
	    int depuis = difference.getDays();*/
 
	    long depuis = java.time.Duration.between(date1, today).toDays();
 
		System.out.println("La différence en nombre de jour entre \n" + date1
				+ " \net \n " + today + " \nest : " + depuis + " jours.");
 
		if (depuis > 9) { // on créer la fenêtre que si nécessaire
			MaFenetre f = new MaFenetre(depuis);
			f.setSize(320, 240); // on dimensionne la fenêtre au besoin (on ne force pas la fenêtre à avoir une taille en mettant ça dans la classe).
			f.setLocationRelativeTo(null); // on centre la fenêtre
			f.setVisible(true); // préférer un affichage externe, ce qui permet de modifier le comportement de la classe d'origine
		}
	}
 
	// préférer une classe statique interne privée à une classe privée (qu'on utilise pour des petits tests temporaires éventuellement)
    private static class MaFenetre extends JFrame { // si la classe étend JFrame, inutile d'avoir une variable interne
 
		public MaFenetre(long depuis) {
 
			setTitle("pas déposé sur LMK depuis " + depuis + " jours");
 
			setContentPane(buildContentPane(depuis));
 
			setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // évite d'avoir à écrire soit-même un WindowAdapter qui fait un exit(0)
 
		}
 
		private JPanel buildContentPane(long depuis) { // la méthode n'a pas besoin d'être public : ça ne sert à rien de l'appeler de l'extérieur
			JPanel panel = new JPanel();
			// panel.setLayout(new FlowLayout()); // inutile : 
			String text = ("coucou " + depuis);
			JLabel label = new JLabel(text);
 
			panel.add(label);
 
			return panel;
		}
 
	}
 
}

Illustration du problème de faire la différence de date... test le et tu verras...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class DemoHeureEte {
 
	public static void main(String[] args) {
 
		Date date1 = new GregorianCalendar(2015,Calendar.MARCH, 28, 23, 30).getTime();
 
		for(int i=0; i<8; i++) {
 
			Date date2 = new GregorianCalendar(2015,Calendar.MARCH, 29, i, 30).getTime();
			long diff = date2.getTime() - date1.getTime();
			System.out.format("Différence entre %tm/%<td/%<ty %<tR et %tm/%<td/%<ty %<tR = %d heure(s) %n", date1, date2, diff/(1000 * 60 * 60 ));
 
 
		}
	}
 
}

La même en java 8 :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class DemoHeureEte {
 
	public static void main(String[] args) {
 
		LocalDateTime date1 = LocalDateTime.of(2015,Month.MARCH, 28, 23, 30);
 
		for(int i=0; i<8; i++) {
 
			LocalDateTime date2 = LocalDateTime.of(2015,Month.MARCH, 29, i, 30);
		    long diff = java.time.Duration.between(date1, date2).toHours();
			System.out.format("Différence entre %tm/%<td/%<ty %<tR et %tm/%<td/%<ty %<tR = %d heure(s) %n", date1, date2, diff);
 
 
		}
	}
 
}

14/04/2015, 11h40
luckyalan

Bonjour,
merci beaucoup Joel pour tes réponses très détaillées.
je t'explique ce qui me perturbe dans mon programme : j'aurai voulu pouvoir transmettre directement la variable au Jlabel à partir du main alors que là je la transmet à la fenêtre qui la transmet au JPanel qui le transmet à la variable text qui s'affiche dans le JLabel... ouf...
n'y a-t'il pas un moyen de transmettre directement du main au JLabel ou éventuellement au moins du main à la variable text qui est dans le JPanel ?
C'est le premier petit bout de prog que je fais en java, sinon avant j'ai fait un peu de C...
Bonne journée et merci encore

Pour transmettre directement au JLabel, il faut avoir une méthode accessible. Ensuite transmettre directement au JLabel, ça veut tout dire et rien dire.

On pourrait avoir :

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
private static class MaFenetre extends JFrame { // si la classe étend JFrame, inutile d'avoir une variable interne
 
                private JLabel label ;
 
		public MaFenetre() {
 
			setTitle();
 
			setContentPane(buildContentPane());
 
			setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // évite d'avoir à écrire soit-même un WindowAdapter qui fait un exit(0)
 
		}
 
		private JPanel buildContentPane() { // la méthode n'a pas besoin d'être public : ça ne sert à rien de l'appeler de l'extérieur
			JPanel panel = new JPanel();
 
			label = new JLabel();
 
			panel.add(label);
 
			return panel;
		}
 
                // premier cas : méthode d'affectation
                public void setDepuis(long depuis) {
                        setTitle("pas déposé sur LMK depuis " + depuis + " jours");
                        String text = ("coucou " + depuis);
			label.setText(text);
                        label.revalidate();                  
                }
 
                // second cas accesseur : à la fois permet de faire plus de chose (comme changer la couleur du JLabel, mais aussi permet de faire n'importe quoi qui pourrait tout pourrir (tant qu'on est le seul à programmer l'application, on sait ce qu'on fait, mais dès qu'on fait des applications professionnelles avec des intervenants multiples, dont des prestataires, ou de l'outsourcing, il faut éviter de laisser des failles ouvertes
                public JLabel getLabel() {
                        return label;
                }
 
	}

Le premier cas s'appellera comme ça :

Code:

1
2
3
4
5
6
7
8
9
if (depuis > 9) { // on créer la fenêtre que si nécessaire
			MaFenetre f = new MaFenetre(depuis);
			f.setSize(320, 240); // on dimensionne la fenêtre au besoin (on ne force pas la fenêtre à avoir une taille en mettant ça dans la classe).
			f.setLocationRelativeTo(null); // on centre la fenêtre
 
                        f.setDepuis( depuis );
 
			f.setVisible(true); // préférer un affichage externe, ce qui permet de modifier le comportement de la classe d'origine
		}

14/04/2015, 20h52
luckyalan

merci Joel,
tu es très pédagogue, bravo
je marque mon sujet "résolu"

une petite aparté s'il te plait : le livre que j'ai acheté est en java 5 et 6... y a t'il vraiment un énorme intérêt à passer à java 8 ? révolution ou juste évolution ?
les livres sur java 8 coûtent très cher, je trouve, alors je compte rester sur 5 et 6

Et bien, c'est toujours difficile de quantifier, mais il y a quelques nouveautés intéressantes en Java 8. Et même en Java 7 d'ailleurs.

Si l'approche fonctionnelle par les streams et l'introduction des expressions lambdas est plus qu'une évolution (ou l'introduction de la classe Optional, que j'apprécie particulièrement pour éviter de faire des if ( truc != null ) tout le temps) , elle ne te sera pas forcément indispensable en tant que débutant en Java, mais était grandement attendue par les développeurs aguerris : donc, révolution, en quelque sorte. On doit noter tout de même la simplification de certaines écritures, mais il est difficile pour moi d'évaluer si c'est vraiment plus simple pour un débutant ou pas.

Pour les expressions-lambda :

Avant Java 8 :
Code:

1 2 3 4 5 6 JButton saveButton = new JButton("Sauver"); saveButton.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { save(); } });
Java 8;
Code:

1 2 JButton saveButton = new JButton("Sauver"); saveButton .addActionListener(e-> save());
A toi de juger ce qui est le simple entre les deux.

Pour les streams :

Avant Java 8 : pour dénombrer les éléments dans une liste
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 public static <T> void compter(List<T> liste) { Map<T, Integer> counters = new HashMap<>(); // avant Java 7 : Map<T, Integer> map = new HashMap<T, Integer>(); for(T elem : liste ) { if( map.containsKey(elem) ) { counters.put( elem, map.get(elem)+1 ); } else { counters.put( elem, 1); } } for(Map.Entry entry : counters) { System.out.println("il y a " + entry.getValue() + " " + entry.getKey() + " dans la liste"); } }
Java 8 :
Code:

1 2 3 4 5 6 public static <T> void compter(List<T> liste) { Map<T,Long> counters = liste.stream().collect(Collectors.groupingBy(c-> c, Collectors.counting())); counters.entrySet().stream().forEach(entry-> System.out.println("il y a " + entry.getValue() + " " + entry.getKey() + " dans la liste") ); }
A toi d'estimer ce qui te semble le plus simple.

Maintenant l'arrivée de l'API java.time simplifie grandement le traitement des dates, heures, périodes, etc... qui est une vraie plaie dans les versions précédentes (au point que beaucoup utilisent une API externe (JODA)).

Pour moi, il n'y a pas d'impératif immédiat pour un débutant à passer à Java 8, mais par contre, passer à Java 7 est quand même plus conseillé. Outre le fait qu'il y a quelques évolutions qui pourraient t'intéresser (en particulier le try-with-resource qui s'implifie les fermetures de flux lors de lecture ou écriture de fichier, l'introduction de java.nio.file qui simplifie de nombreuses opérations sur les fichiers, ou, plus anecdotique, le switch sur les chaines qui simplifie quand même l'écriture de tests), Java 6, et en encore moins Java 5, ne sont plus maintenus par Oracle, ce qui veut dire des problèmes éventuels diverses qui ne seront plus corrigés (avec une mention spéciale pour tout ce qui est sécurité).

Par exemple,
avant Java 7 :
Code:

1 2 3 4 5 6 7 8 9 if ( "valeur1".equals( truc ) ) { // faire quelque chose } else if ( "valeur2".equals( truc ) ) { // faire quelque chose } else if ( "valeur3".equals( truc ) ) { // faire quelque chose } else { // faire quelque chose }
Java 7 :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 switch ( truc ) { case "valeur1": // faire quelque chose break; case "valeur2": // faire quelque chose break; case "valeur3": // faire quelque chose break; default: // faire quelque chose break; }
Ou, pour afficher le contenu d'un fichier :

Avant Java 7 :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 public void afficher(String file) { try { BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(new File(file)))); try { for(String line = reader.readLine(); line!=null; line=reader.readLine()) { // traitement } } finally { reader.close(); } } catch( IOException e ) { e.printStackTrace(); } }
Java 7 :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 public void afficher(String file) { try(BufferedReader reader = Files.newBufferedReader(Paths.get(file))) { for(String line = reader.readLine(); line!=null; line=reader.readLine()) { // traitement } } catch( IOException e ) { e.printStackTrace(); } }
A noter aussi, si tu fais ce choix, les évolutions sur l'environnement graphique JavaFX.

Pour l'aspect prix des livres, tu trouveras de nombreux tutoriels sur le site Developpez et ils sont tous gratuits. Et puis il y a le forum Java pour les complétements.

PS: la liste des évolutions n'est pas exhaustive.

15/04/2015, 10h51
luckyalan

merci Joel,
Ton explication super précise et bien illustrée : je pense qu'elle servira aussi à d'autres qui se posent la question.
Bon ! je suis un peu rassuré car le livre que j'ai inclut le switch de la version 7.
je vais aller voir les tutos du site. c'est difficile pour un débutant de trouver des tutos qui soient à la fois modernes, complets et abordables au niveau des connaissance...
15/04/2015, 11h07
joel.drigo

Citation:

Envoyé par luckyalan

je vais aller voir les tutos du site. c'est difficile pour un débutant de trouver des tutos qui soient à la fois modernes, complets et abordables au niveau des connaissance...

Pour le coup, il faut se méfier : certains tutoriels sont assez anciens (il faut faire attention à la date) et ne prennent pas toujours en compte les dernières évolutions de syntaxe. Il y a beaucoup de travail pour les remettre à jour et on manque de ressources pour s'en occuper, mais ça arrivera.