JFrameUne fenêtre est un objet de type
JFrame, classe à laquelle on
accède avec la commande d’importation
import javax.swing.*. Nous utiliserons les méthodes suivantes :
public void setTitle(String title), pour définir le titre
de la fenêtre.
public void setVisible(boolean b), pour afficher la
fenêtre.
public void pack(), pour adapter les dimensions
de la fenêtre aux composants qu’elle contient.
public void setDefaultCloseOperation(int operation), pour
déterminer le comportement de la fenêtre lors de sa fermeture.
Voici un code de création d’une fenêtre vide.
package ihm;
import javax.swing.*;
public class PremiereFenetre
{
public static void main(String[] args)
{
JFrame f = new JFrame();
f.setVisible(true);
f.setTitle("My first window !");
f.setSize(200, 200);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
Nous allons ajouter un bouton dans notre fenêtre. Les boutons sont de
type
JButton, le constructeur de cette classe prend en
paramètre le libellé du bouton. Un des attributs de la classe JFrame
est un objet contenant tous les composants graphiques de la fenêtre,
on accède à cet objet par la méthode
public Container getContentPane(). Tout
Container possède une méthode
public Component add(Component comp) permettant d’ajouter
n’importe quel composant graphique (par exemple un
JButton...). On ajoute donc un Bouton de la façon suivante
getContentPane().add(new JButton("my First JButton"));.
package ihm;
import javax.swing.*;
import java.awt.*;
public class PremiersJButtons
{
public PremiersJButtons()
{
JFrame frame = new JFrame();
frame.setTitle("My second window !");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Container container = frame.getContentPane();
container.setLayout(new FlowLayout());
container.add(new JButton("my First JButton"));
container.add(new JButton("my Second JButton"));
container.add(new JButton("my Third JButton"));
frame.setVisible(true);
frame.pack();
}
public static void main(String[] args)
{
new PremiersJButtons();
}
}
L’instruction
getContentPane().setLayout(new FlowLayout());
sert à préciser de quelle façon vous souhaitez que les composants
soient disposés dans la fenêtre. Nous reviendrons dessus.
Un écouteur d’événement est un objet associé à un composant
graphique. Cet objet doit implémenter l’interface
ActionListener et de ce fait contenir une méthode
public void actionPerformed(ActionEvent e). Cette méthode est
appelée à chaque fois qu’un événement se produit sur le
composant. L’objet
ActionEvent contient des informations sur
l’événement en question.
Dans ce premier exemple, nous allons définir une classe
public class PremierEcouteur implements ActionListener.
Elle servira donc à la fois à contenir la fenêtre et
d’écouteur d’événements. L’objet de type
ActionEvent passé en
paramètre contient une méthode
public Object getSource()
retournant l’objet ayant déclenché l’événement.
package ihm;
import javax.swing.*;
import java.awt.event.*;
import java.util.ArrayList;
import java.awt.*;
public class PremierEcouteur implements ActionListener
{
@Override
public void actionPerformed(ActionEvent e)
{
System.out.println("Click on " + ((JButton) e.getSource()).getText());
}
public PremierEcouteur()
{
JFrame frame = new JFrame();
ArrayList<JButton> jButtons = new ArrayList<>();
frame.setTitle("My third window !");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.getContentPane().setLayout(new FlowLayout());
jButtons.add(new JButton("my First JButton"));
jButtons.add(new JButton("my Second JButton"));
jButtons.add(new JButton("my Third JButton"));
for (JButton jButton : jButtons)
{
frame.getContentPane().add(jButton);
jButton.addActionListener(this);
}
frame.setVisible(true);
frame.pack();
}
public static void main(String[] args)
{
new PremierEcouteur();
}
}
Les classes anonymes sont des classes que l’on peut créer "à la
volée", c’est-à-dire au moment de leur instanciation.. On s’en sert
généralement pour implémenter une interface, en l’occurrence
ActionListener. Voici une autre implémentation faisant
intervenir des classes anonymes.
package ihm;
import javax.swing.*;
import java.awt.event.*;
import java.util.ArrayList;
import java.awt.*;
public class EcouteurAnonyme
{
public EcouteurAnonyme()
{
JFrame frame = new JFrame();
ArrayList<JButton> jButtons = new ArrayList<>();
frame.setTitle("My fourth window !");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.getContentPane().setLayout(new FlowLayout());
jButtons.add(new JButton("my First JButton"));
jButtons.add(new JButton("my Second JButton"));
jButtons.add(new JButton("my Third JButton"));
jButtons.add(new JButton("my Fourth JButton"));
jButtons.add(new JButton("my Fifth JButton"));
jButtons.add(new JButton("my Sixth JButton"));
jButtons.add(new JButton("my Seventh JButton"));
for (JButton button : jButtons)
frame.getContentPane().add(button);
/* Classe dediee */
jButtons.get(0).addActionListener(new Ecouteur());
/* Classe anonyme */
jButtons.get(1).addActionListener(new ActionListener()
{
@Override
public void actionPerformed(ActionEvent e)
{
System.out.println("click on Second JButton");
}
});
/* Classe anonyme dans une fonction */
jButtons.get(2).addActionListener(getEcouteur());
/* Lambda expression */
jButtons.get(3).addActionListener(
(e) -> {System.out.println("click on Third JButton");}
);
/* Lambda expression dans une fonction */
jButtons.get(4).addActionListener(getEcouteurLambda());
/* Double colon */
jButtons.get(5).addActionListener(this::ecouteurDoubleColon);
/* Double colon dans une fonction*/
jButtons.get(6).addActionListener(getEcouteurDoubleColon());
frame.pack();
frame.setVisible(true);
}
private ActionListener getEcouteur()
{
return new ActionListener()
{
@Override
public void actionPerformed(ActionEvent e)
{
System.out.println("click on Fourth JButton");
}
};
};
private ActionListener getEcouteurDoubleColon()
{
return EcouteurAnonyme.this::autreEcouteurDoubleColon;
}
private ActionListener getEcouteurLambda()
{
return (e) -> {System.out.println("click on Fifth JButton");};
};
private void ecouteurDoubleColon(ActionEvent e)
{
System.out.println("click on Sixth JButton");
};
private void autreEcouteurDoubleColon(ActionEvent e)
{
System.out.println("click on Seventh JButton");
};
public static void main(String[] args)
{
new EcouteurAnonyme();
}
}
class Ecouteur implements ActionListener
{
@Override
public void actionPerformed(ActionEvent e)
{
System.out.println("click on First JButton");
}
}
Un gestionnaire de mise en forme (Layout manager) est un objet
permettant de disposer les composants et les conteneurs dans la
fenêtre. Nous avons utilisé un gestionnaire de type
FlowLayout, qui dispose les composants les uns à coté des
autres (ou au dessus des autres si ce n’est pas possible) dans leur
ordre d’ajout. Le gestionnaire
GridLayout représente le
conteneur comme une grille
package ihm;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class TestGridLayout
{
private JLabel labelTitre;
private JPanel getTitrePanel()
{
JPanel panel = new JPanel();
panel.add(getLabelTitre());
return panel;
}
private JPanel getBoutonsPanel()
{
JPanel panel = new JPanel();
panel.setLayout(new GridLayout(2, 2));
panel.add(getBouton("North-West"));
panel.add(getBouton("North-East"));
panel.add(getBouton("South-West"));
panel.add(getBouton("South-East"));
return panel;
}
private JPanel getMainPanel()
{
JPanel panel = new JPanel();
panel.setLayout(new BorderLayout());
panel.add(getTitrePanel(), BorderLayout.NORTH);
panel.add(getBoutonsPanel(), BorderLayout.SOUTH);
return panel;
}
private JLabel getLabelTitre()
{
labelTitre = new JLabel("Le Titre");
return labelTitre;
}
private JButton getBouton(String titre)
{
JButton bouton = new JButton(titre);
bouton.addActionListener(getBoutonAction(titre));
return bouton;
}
private ActionListener getBoutonAction(String titre)
{
return (e) ->
{
labelTitre.setText(titre);
};
}
public TestGridLayout()
{
JFrame frame = new JFrame("Une fonction par panel, une fonction par composant");
frame.setContentPane(getMainPanel());
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.pack();
frame.setVisible(true);
}
public static void main(String[] args)
{
new TestGridLayout();
}
}
package ihm;
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
public class Carre
{
private JTextField operandTextField;
private JLabel resultLabel;
private void afficheCarre()
{
try
{
long k = Long.parseLong(operandTextField.getText());
k *= k;
resultLabel.setText("" + k);
}
catch (NumberFormatException e)
{
resultLabel.setText("");
}
}
private KeyListener getKeyListener()
{
return new KeyAdapter()
{
@Override
public void keyTyped(KeyEvent e)
{
afficheCarre();
}
};
}
private JLabel getLabelTitre()
{
return new JLabel("Calculatrice de carré");
}
private JLabel getLabelX()
{
return new JLabel("x = ");
}
private JLabel getLabelX2()
{
return new JLabel("x^2 = ");
}
private JLabel getLabelResultat()
{
resultLabel = new JLabel();
return resultLabel;
}
private JTextField getTextFieldOperand()
{
operandTextField = new JTextField();
operandTextField.addKeyListener(getKeyListener());
return operandTextField;
}
private JPanel getPanelTitre()
{
JPanel panel = new JPanel();
panel.add(getLabelTitre());
return panel;
}
private JPanel getPanelCalculatrice()
{
JPanel panel = new JPanel();
panel.setLayout(new GridLayout(2, 2));
panel.add(getLabelX());
panel.add(getTextFieldOperand());
panel.add(getLabelX2());
panel.add(getLabelResultat());
return panel;
}
private JPanel getPanelMain()
{
JPanel panel = new JPanel();
panel.setLayout(new BorderLayout());
panel.add(getPanelTitre(), BorderLayout.NORTH);
panel.add(getPanelCalculatrice(), BorderLayout.CENTER);
return panel;
}
public Carre()
{
JFrame frame = new JFrame();
frame.setTitle("Square computer !");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setContentPane(getPanelMain());
frame.setVisible(true);
frame.pack();
}
public static void main(String[] args)
{
new Carre();
}
}