Discussion :

[GuysmaL]

Bonjour à tous,

Je suis en train de développer un petit calculateur que j'aimerais mettre en forme avec une interface graphique.
Le problème est que je suis complètement perdu avec les différentes classes à utiliser.
Pour le moment j'affiche une fenêtre, un slider ainsi qu'un bouton de lancement du programme Main. La valeur du slider est utilisée pour amorcer le lancement du calcul.

Est ce que je dois créer une seule classe IHM dans laquelle je défini tous les objets ?
Est ce que je dois créer des classe Fenetre, Slider, Button ?
Est ce que je dois coder dans le Main ou faire en sorte de définir des attributs ?

Voici ce que j'ai fais pour le moment :

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
52
53
54
55
 
public class IHM{
 
	public static void main(final String[] args) {
 
		final VilainHand vH = new VilainHand();
 
		// Instanciation des objets
		JFrame f = new JFrame ("Calculator");
		final JLabel label = new JLabel("Main actuelle : ..");
	         final JButton bRun = new JButton ("Run");
		JSlider slide = new JSlider();
 
		 // Definir la fenetre
		f.setSize (750, 250);
		f.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE); // Fermeture fenetre
 
	    // Definir le slider
	    slide.setMaximum((Calculator.vilainHand.length-1));
	    slide.setMinimum(0);
	    slide.setValue(30);
	    slide.setMinorTickSpacing(10);
	    slide.setMajorTickSpacing(20);
 
	    ChangeListener cl = new ChangeListener() {    // Ecouter le slider
			@Override
			public void stateChanged(ChangeEvent eventSlider) {
				label.setText("Main actuelle : " +vH.getIndex(((JSlider)eventSlider.getSource()).getValue()));}
		};	    
 
 
		bRun.addActionListener(new ActionListener() {   // Ecouter le boutton run
			@Override
			public void actionPerformed(ActionEvent e) {
				 Copy_Main.main(args);		
			}
		});
	    slide.addChangeListener(cl);
 
 
	    //getContentPane permet d'obtenir la zone conteneur de la fenetre
	    Container contentpane = f.getContentPane();
 
	    //Ajout du BTN au sud
	    contentpane.add(bRun, BorderLayout.SOUTH);
	    contentpane.add(slide,BorderLayout.NORTH);
	    contentpane.add(label,BorderLayout.EAST);
 
		// Affichage
		f.setVisible (true);
		slide.setVisible (true);
 
 
	}	
}

Ensuite j'imagine l'instancier dans le Main de mon programme principal :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
public class Calculateur {
 
   public static void main(String[] args) {
 
   IHM intGraphique = new IHM();
 
   // Démarrage du calcul
   ..
   ..

Si quelqu'un pourrait m'orienter un peu, je lui en serrai reconnaissant !

Merci

[joel.drigo]

Salut

Est ce que je dois créer une seule classe IHM dans laquelle je défini tous les objets ?
Est ce que je dois créer des classe Fenetre, Slider, Button ?
Est ce que je dois coder dans le Main ou faire en sorte de définir des attributs ?

La réponse à toutes ces questions est oui et non. Enfin, je veux dire, ça dépend.

Il t'est inutile de faire une classe Slider ou Button. La classe JSlider existe. La classe JButton aussi. Si tu devais étendre le fonctionnement standard du bouton Swing, tu pourrais envisager de faire une classe MyButton qui étend JButton. Sinon, non seulement ça ne sert à rien, mais le risque de rendre le programme moins facilement compréhensible par d'autres personnes qui ne reconnaitront pas directement les composants utilisés.

Pour un JPanel, ou une JFrame, faire une classe se justifie principalement dans 3 cas :

• Tu dois maintenir des attributs pour ton traitement : il te faut donc une classe pour ces attributs. En particulier, si d'autres parties du programme vont avoir besoin de manipuler ces attributs (via des accesseurs ou mutateurs). On peut éventuellement faire une classe qui ne maintient que les attributs, dont les composants : cette classe n'a donc pas besoin d'étendre JFrame ou JPanel, ou une autre classe de Swing.
• Il s'agit d'un agencement de composants que tu as besoin d'utiliser à plusieurs endroits dans ton programme : ça t'évitera donc de dupliquer du code. Quoiqu'il existe une autre façon de faire : la fabrique (une méthode qui créé le panel ou la frame et qu'on peut donc appeler à plusieurs endroits).
• Si tu as un besoin de faire une hiérarchie de composants : avoir une classe avec une base d'IHM, et d'autres qui l'étendent en ajoutant des comportements, d'autres composants, etc. Là, aussi, on pourrait le gérer par fabrique (moins facile à étendre), ou par décorateur. On peut aussi citer le cas de vouloir fournir une base de composants personalisable par redéfinition de méthodes.

Pour ce qui est coder dans le main, ou faire une classe avec une méthode du type lancerIHM(), je dirais que ça dépend un peu de ce que va devenir le programme : si c'est juste un petit programme rapide, construire sa frame dans le main n'est ni mieux ni moins bien qu'autre chose. Si l'application doit pouvoir évoluer, et que tu veux ajouter d'autres types de composants, ce serait mieux de séparer le lancement des UI, au moins dans des méthodes distinctes. Mais tu pourras toujours le faire plus tard : ce n'est pas très complexe de renommer la méthode main(String[] args) en lancerUI() et de recréer un main(Strng[] args) qui l'appelle, pour commencer la refactorisation.

Dans le même genre, afin de pouvoir avoir d'autres composants de calcul, il pourrait être intéressant de mettre à part la construction du panel (avec le slider, le bouton, etc), ce qui permettrait par exemple d'avoir une UI avec une combo qui permet de choisir le composant de calcul à utiliser. Il y aurait plusieurs panels, un par composant de calcul, et on utiliser un CardLayout dans le contentPane afin d'afficher tous ces composants. Mais c'est pareil : migrer vers cette architecture est assez rapide en partant de ton programme.

En résumé, les questions que tu te poses sont légitimes, et il faut les anticiper, mais ça ne sert à rien de faire 36 classes juste pour faire des classes. Faire des classes lorsque ça se justifie par le besoin de modularité, de réutilisation, d'extension, etc.

En revanche, n'utilise main(String[] args) que lorsqu'il s'agit d'un point d'entrée de programme. Surtout s'il n'y a aucun paramètre nécessaire.
En plus, ton code de la classe Calculateur n'est pas cohérent avec le fait que ton IHM se lance par une méthode statique. Le lancement de ton ihm se fait par une méthode statique : il est donc inutile de créer une instance de classe IHM.
Ce qui est gênant aussi, c'est Copy_Main.main(args); : ça limite ton UI à appeler cette méthode statique. Ce serait plus intéressant de passer en paramètre le moyen d'appeler la méthode de calcul (par interface, ou par lambda). C'est également vrai pour l'instance de VilainHand. Ton IHM devient ainsi indépendante du traitement, et peut être réutilisée pour faire d'autres traitements qui utiliseraient la même IHM. En l'occurence, en l'état, ton calcul n'utilise pas de paramètre provenant de l'IHM (du slider). Ou alors cela se passe de manière indirecte, avec des méthodes et attributs statiques, ce qui est bien pire que de ne pas faire de classes pour une JFrame à 3 composants

[GuysmaL]

Merci beaucoup joel.drigo pour cette réponse complète !
Je te cache pas que je n'ai pas tout compris par rapport à ton dernier paragraphe. Je débute Java depuis quelques mois et j'ai encore de belles lacunes à fixées.

Concernant mon programme, je suis le seul à coder dessus et je ne pense pas rajouté de contenu par la suite.
Là ou l'IHM est importante c'est qu'elle me permettra de cocher quelques boutons de paramètres et de définir la taille du tableau initial pour le calcul avec justement, ce slider.

Hier j'ai justement opté pour introduire l'IHM directement dans le main (je crois que j'ai un peu tout essayé mais je suis vite stoppé par mes lacunes )
L'avantage, c'est que je peux réutiliser la valeur de ce slider pour initialiser le nouveaux tableau, je l'ai juste faite passé dans une var globale.
Puis je suis passé à autre chose parce que l'IHM et le code se lançaient l'un après l'autre. Pas le temps de paramétrer quoi que ce soit. J'ai recherché sur le net pour une sorte de "pause" entre la partie IHM et Calculateur pour ensuite appuyer sur le bouton de lancement mais sans succès. D'un côté je suis content d'avoir essayé cette méthode car c'est un peu ce que tu me conseils, vu la taille du programme.

Concernant les autres paramètres à venir, ils permettront aussi de modifier ce tableau de données (avec des boutons radios). C'est la seule partie du programme qui changera et je devrais obligatoirement répercuter l'action de ces buttons sur ma classe vilainHand. C'est dans cette classe que se trouve le tableau de base pour le calcul. Je l'ai instancier afin d'obtenir dans le label la valeur courante quand je bouge le slider. Cette partie est obligatoire. Je crois que ca répond en partie à ca :

C'est également vrai pour l'instance de VilainHand. Ton IHM devient ainsi indépendante du traitement, et peut être réutilisée pour faire d'autres traitements qui utiliseraient la même IHM. En l'occurence, en l'état, ton calcul n'utilise pas de paramètre provenant de l'IHM (du slider). Ou alors cela se passe de manière indirecte, avec des méthodes et attributs statiques, ce qui est bien pire que de ne pas faire de classes pour une JFrame à 3 composants

En plus, ton code de la classe Calculateur n'est pas cohérent avec le fait que ton IHM se lance par une méthode statique. Le lancement de ton ihm se fait par une méthode statique : il est donc inutile de créer une instance de classe IHM.

Effectivement elle sert à rien ici. Le Main d'IHM lancera automatiquement le Main de Calculateur.

Le cheminement est très linéaire, c'est pour ça qu'au début je voulais le faire avec AutoIT pour me faciliter la vie mais je veux apprendre d'avantage de Java.
Du coup tu me conseils de partir sur une IHM présente dans le Main de Calculateur ?

Encore merci de ton aide !

[joel.drigo]

Ce n'est pas très grave pour le moment si tu utilises des variables public static, ou des liens d'appel par méthodes statiques : tu auras l'occasion plus tard de te rendre compte dans des applciations plus importantes que ça te gênera et tu le feras de moins en moins (c'est simplement que quand on prend l'habitude dès le départ de ne pas le faire, c'est plus facile ensuite, ça devient un réflexe). Au passage, ça n'existe pas les variables globales en Java. Une public static peut y ressembler dans le fait qu'on peut y accèder de n'importe où, mais ça n'a rien à voir avec une variable globale.
Bref, l'important c'est surtout que tu ne fasses pas 36 classes qui ne servent à rien, qui te donne du boulot inutile, qui te complique le code (donc le rende plus difficile à déboguer).

En ce qui concerne le problème de l'instanciation de IHM alors que la méthode est statique : lorsqu'une méthode est statique, il suffit de l'invoquer par le nom de la classe. Par exemple :

Code :

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

1
2
3
4
5
public class IHM {
    public static void uneMethode() {
          /**... qui fait des trucs ...**/
    }
}

Il suffit d'écrire :

Code :

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

1
2
3
4
5
public class Launcher {
    public staitc void main(String[] args) {
         IHM.uneMethode();
    }
}

Pas besoin de new IHM()...

Au sujet d'avoir une méthode main(String[] args) :
Si tu as

Code :

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

1
2
3
4
5
public class IHM {
    public static void main(String[] args) {
          /**... qui fait des trucs sans utiliser args ...**/
    }
}

Tu vas devoir appeler la méthode main en passant des arguments qui ne servent à rien. Et si tu avais besoin d'arguments, avoir des arguments dédiés, dans le bon type, au lieu d'un tableau de String sera plus simple à utiliser :

Code :

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

1
2
3
4
5
public class IHM {
    public static void afficherFenetre(int width, int height) {
          /**... qui créé une JFrame, lui donne la taille passée en paramètre et l'affiche ...**/
    }
}

Il peut être d'ailleurs intéressant de retourner la frame :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class IHM {
    public static JFrame showFrame() {
         final Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
         return showFrame(screenSize.width, screenSize.height);
    }
    public static JFrame showFrame(int width, int height) {
            JFrame frame = new JFrame("Mon application");
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            frame.setSize(width, height);
            frame.setLocationRelativeTo(null);
            frame.setVisible(true);
            return frame;
    }
}

Tu pourras l'appeler et récupérer la frame créée(JFrame frame = IHM.showFrame()), pour modifier son comportement au besoin.

[GuysmaL]

Merci beaucoup pour tous ces conseils, mon IHM commence à prendre forme doucement !