Discussion :

[jbv]

Bonjour,

Je commence a construire des interfaces graphiques avec Java et je me questionne concernant les separations entre les interfaces, les listener et les classes utilitaires. Pour illustrer mon propos j'ai fait un petit prog qui somme deux entier :

La premiere classe est la fonction de sommation :

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
 
public class Sommateur {
	private int a,b;
 
	public Sommateur(){
		a=0;
		b=0;
	}
 
	public void setA(int a) {
		this.a = a;
	}
 
	public void setB(int b) {
		this.b = b;
	}
 
	public int getSum(){
		return (a+b);
	}	
 
}

La deuxieme classe est l'interface graphique :

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
 
import ...
 
public class TestPanel extends JPanel {
	JButton unBouton;
	JLabel unLabel;
	JTextField entreA, entreB;
 
	Sommateur laSomme;
	ListenerBouton leListener;
 
	public TestPanel() {
		super();
		entreA = new JTextField("10");
		entreB = new JTextField("14");
		unBouton = new JButton("Sommer");
		unLabel = new JLabel("Cliquez sur sommer pour le résultat");		
		this.setLayout(new GridLayout(2,2));
		this.add(entreA);
		this.add(entreB);
		this.add(unBouton);
		this.add(unLabel);
 
		laSomme = new Sommateur();
		leListener = new ListenerBouton(this,laSomme);
 
		unBouton.addActionListener(leListener);				
	}
}

La troisième classe est le Listener

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
 
import ...
 
public class ListenerBouton implements ActionListener {
	TestPanel myPanel;
	Sommateur mySommateur;
 
	public ListenerBouton(TestPanel unPanel, Sommateur unSommateur){
		myPanel = unPanel;
		mySommateur = unSommateur;
	}
 
	public void actionPerformed(ActionEvent e) {
		// TODO Auto-generated method stub
		mySommateur.setA(Integer.valueOf(myPanel.entreA.getText()).intValue());
		mySommateur.setB(Integer.valueOf(myPanel.entreB.getText()).intValue());		
		myPanel.unLabel.setText("Le résultat est : " + String.valueOf(mySommateur.getSum()));
	}
}

Enfin la dernière classe est "l'execution"

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
 
import javax.swing.JFrame;
public class TestFrame extends JFrame {
	TestPanel lePanel;	
 
	public TestFrame(){
		super("Une frame");
		lePanel = new TestPanel();
		this.setContentPane(lePanel);
		this.pack();
		this.setVisible(true);				
	}
 
	public static void main(String[] args) {
		TestFrame fen = new TestFrame();
	}
}

Voila, mes questions ...
Est ce que cette implémentation correspond bien à une séparation intereface/action
D'autre part, je vais enseigner les bases de la création d'interfaces graphiques en Java l'an prochain, est-ce une bonne approche de tuot séparer comme je l'ai fait ?

Merci d'avance à ceux qui m'eclaireront

JB

PS : la question subsidiaire pour départager les gagnants
Est-ce bien de créer une applet avec le même but de la façon suivante :

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
import javax.swing.JApplet;
 
public class TestApplet extends JApplet {
 
	TestPanel lePanel;
 
	public TestApplet(){
		super();
		lePanel = new TestPanel();
		this.setContentPane(lePanel);		
		this.setVisible(true);		
	}
 
	public void init(){	
	}
}

Encore merci !

[ Modéré par Bulbo ]
Modification du titre
Les Règles du Forum

[Oui-Oui MB]

C'est toujours mieux de séparer comme tu l'as fait. De plus, ton code n'en sera que beaucoup plus clair.

Maintenant tu seras peut-être déboussolé en passant sur un IDE qui génere le code à ta place. En effet, la plupart du temps, ces éditeurs passent par des classes anonymes du style new ActionListener{}....

[jbv]

Merci pour la reponse.
J'ai effectivement constaté que les IDE passaient par les classes anaonymes, dans ce cas l'objet Listener et l'objet Frame sont communs. La separation entre l'applicatif et l'interface reste toutefois vrai, ce qui est le plus important, je pense (?)
JB

[xavlours]

Un autre schéma très lisible (tout en séparant le graphique de l'applicatif)est :

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
public class TestPanel extends JPanel implements ActionListener{ 
   JButton unBouton; 
   JLabel unLabel; 
   JTextField entreA, entreB; 
 
   Sommateur laSomme; 
 
   public TestPanel() { 
      super(); 
      entreA = new JTextField("10"); 
      entreB = new JTextField("14"); 
      unBouton = new JButton("Sommer"); 
      unLabel = new JLabel("Cliquez sur sommer pour le résultat");       
      this.setLayout(new GridLayout(2,2)); 
      this.add(entreA); 
      this.add(entreB); 
      this.add(unBouton); 
      this.add(unLabel); 
 
      laSomme = new Sommateur(); 
 
      unBouton.addActionListener(this);             
   }
 
  public void actionPerformed(ActionEvent e) { 
      // TODO Auto-generated method stub 
      laSomme.setA(Integer.parseInt(myPanel.entreA.getText());
      laSomme.setB(Integer.valueOf(myPanel.entreB.getText()).intValue());       
      unLabel.setText("Le résultat est : " + String.valueOf(laSomme.getSum())); 
   } 
 
}

Cela permet d'accéder à ta classe applicative (Sommateur) lors des clics, ce qui évite une référence croisée Listener-ClasseGraphique, et qui épargne de mettre trop de getters-setters.
On pourrait parler longtemps des cas ou l'un est plus lisible que l'autre, mais les deux sont propres.

[cpr0]

La solution de xavlours est effectivement intéressante à partir du moment ou le code n'est pas trop long auquel cas il vaut mieux détacher le ou les listeners. Il suffit effectivement ensuite de passer au constructeur du listener une référence à l'objet qui écoute pour pouvoir utliser certaines propriétés à l'aide de getters/setters.

Bonne continuation...