Convertisseur Euro qui permet de manipuler les JFrame, les JCheckBox, les JTextField,
les JButton, les Exceptions et l'Interface ActionListener
Pas Mal pour une première application ou pour débuter avec les GUI
Source / Exemple :
/********************************************
*
- Classe à mettre dans un fichier Main.java
*
import java.awt.Dimension;
import java.awt.*;
/**
- Classe qui est le point d'entrée de l'application
- C'est elle qui va lancer la fenêtre de convertisseur
-
- @author Duss
- /
public class Main
{
public static void main(String[] args)
{
// Déclaration d'un objet de type Convertisseur
// et instanciation de ce même objet
Convertisseur fen = new Convertisseur();
// Affectation d'une taille
fen.setSize(450,410);
// Affichage
fen.setVisible(true);
// Définition du titre
fen.setTitle("Convertisseur");
// On récupère la taille de l'écran (la résolution)
// et on place notre fenêtre au milieu
Dimension screen = Toolkit.getDefaultToolkit().getScreenSize();
fen.setLocation((screen.width - fen.getSize().width)/2,(screen.height - fen.getSize().height)/2);
}
}
/********************************************
*
- Classe à mettre dans un fichier Convertisseur.java
*
import java.awt.Container;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
/**
- Classe permettant de faire des conversions
- entre les francs et les euros.
*
- La classe "hérite" (extends) de JFrame pour pouvoir
- afficher une fenetre à l'écran.
*
- Elle "implémente" (implements) l'Interface ActionListener
- c'est à dire qu'elle doit redéfinir toutes les méthodes
- de cette Interface.
- Ici il n'y en à qu'une : actionPerformed
- Cela permet d'intercepter toutes les actions qui
- se passent dans la fenetre (les clicks par exemple)
*
public class Convertisseur extends JFrame implements ActionListener
{
// Constantes pour ameliorer la lisibilité du code
public static final int VERS_FRANCS = 1;
public static final int VERS_EUROS = 2;
public static final double TAUX = 6.55957;
// Attributs de la classe
private JLabel _labVal, _labRes;
private JTextField _txtVal, _txtRes;
private JButton _conv;
private JCheckBox _euro, _franc;
/** Constructeur : c'est la méthode qui se lance
- quand on fait un new sur notre classe
- /
public Convertisseur()
{
// On récupère l'objet de la fenetre
// sur lequel on va pouvoir ajouter
// nos composants graphiques.
Container cont = getContentPane();
// On crée 2 JPanel qui sont des "panneaux"
// sur lesquels on peut poser des composants
// cela va permettre d'avoir une mise en page
// avec 2 layouts différents
JPanel haut = new JPanel();
JPanel bas = new JPanel();
// Le layout de notre panel du haut
// est une grille de 3 lignes et 2 colonnes
haut.setLayout(new GridLayout(3,2));
// Création des JLabels
_labVal = new JLabel("Valeur");
_labRes = new JLabel("Resultat");
// Création des JTextField
_txtVal = new JTextField();
_txtRes = new JTextField();
// Création des JCheckBox
_euro = new JCheckBox("Euros");
_franc = new JCheckBox("Francs");
// Euro est cochée, franc ne l'est pas
_euro.setSelected(false);
_franc.setSelected(true);
// Création du bouton
_conv = new JButton("Conversion");
// On indique que notre fenetre (this = la classe dans laquelle
// on se trouve) est chargée "d'écouter" les actions du bouton
// et des cases a cocher
_conv.addActionListener(this);
_euro.addActionListener(this);
_franc.addActionListener(this);
// On ajoute le panel haut en haut de la feuille
// et celui du bas en dessous
cont.add(haut,"North");
cont.add(bas);
// On ajoute les composants labels, textField et
// checkBox au panel haut
haut.add(_labVal);
haut.add(_txtVal);
haut.add(_labRes);
haut.add(_txtRes);
haut.add(_euro);
haut.add(_franc);
// Le bouton a celui du bas
bas.add(_conv);
}
/**
- Fonction de conversion
- On utilise les noms des constantes pour
- améliorer la lisibilité du code
*
- @param valeur la valeur à convertir
- @param sens le sens de conversion
- @return Un double qui est le résultat de la conversion
- /
public double conv(double valeur, int sens)
{
double res;
if (sens == VERS_FRANCS)
res = valeur / TAUX;
else
res = valeur * TAUX;
return res;
}
/**
- Fonction pour arrondir
- On décale le nombre en le multipliant
- par 10 puissance le nombre de décimales
- que l'on veut.
- On fait un round dessus (arrondi à l'entier)
- Puis on redécale en divisant par
- 10 puissance le nombre de décimales.
*
- @param val La valeur à arrondir
- @param nbDec Le nombre de décimales
- @return Un double qui est l'arrondi
- /
public double arrondir(double val, int nbDec)
{
return Math.round(val * Math.pow(10,nbDec)) / Math.pow(10,nbDec);
}
/**
- Méthode de l'interface ActionListener
*
- @param e L'actionEvent correspondant à l'action
- /
public void actionPerformed(ActionEvent e)
{
// En faisant e.getSource() on récupère
// le composant qui à générer l'action
// on peut donc faire des traitements différents
// Cas ou c'est le bouton
// On va faire la conversion
if (e.getSource() == _conv)
{
// Vérification qu'il y a bien quelque chose
// à convertir. Si non, on affiche un message
if (_txtVal.getText().equals(""))
JOptionPane.showMessageDialog(this,"Veuillez saisir une valeur !");
else
{
int sens;
double val = 0;
// On teste quel case est cochée
// et on détermine le sens de conversion
if (_euro.isSelected())
sens = VERS_EUROS;
else
sens = VERS_FRANCS;
// La fonction parseDouble lance des
// exceptions de type numberFormatException
// si le String à parser n'est pas un double valide
// on va donc intercepter cette possible
// exception en l'entourant d'un bloc try/catch
// try sert à prévenir qu'une exception peut survenir
// catch sert à la récupérer et à faire un
// traitement approprié. Ici, l'affichage d'un message
try
{
val = Double.parseDouble(_txtVal.getText());
}
catch (NumberFormatException ex)
{
JOptionPane.showMessageDialog(this,"Veuillez saisir un nombre !");
}
// On appelle la fonction pour arrondir
double res = arrondir(conv(val,sens),2);
// On affiche le texte
_txtRes.setText(String.valueOf(res));
}
}
// Traitement pour que les 2 cases à cocher
// ne soit pas cochées en même temps :
// Cas ou c'est la case euro qui a généré l'action
// La case franc prend la valeur inverse de euro
if (e.getSource() == _euro)
_franc.setSelected(!_euro.isSelected());
// Cas ou c'est la case franc qui a généré l'action
// La case euro prend la valeur inverse de franc
if (e.getSource() == _franc)
_euro.setSelected(!_franc.isSelected());
}
}
Conclusion :
Voilà, bon pour ceux qui préfèrent mettre tout dans un seul fichier, on peut aussi,
il suffit de mettre la méthode Main.main dans Convertisseur.
Je trouve que comme ça c'est un peu plus 'propre'.
Mais c'est des manies de coder ;)
J'ai essayé d'être le plus clair possible dans mes commentaires pour
que ce source puisse apporter un max d'info aux débutants.
Si malgrès tout vous trouvez que c'est du patois, demandez moi des précisions
ou donnez les directements !!
Duss
Si vous avez des questions n'hésitez pas
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.