• 40 heures
  • Difficile

Ce cours est visible gratuitement en ligne.

Ce cours existe en livre papier.

course.header.alt.is_certifying

J'ai tout compris !

Mis à jour le 03/06/2020

TP : créez une calculatrice

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Ah ! Ça faisait longtemps… Un petit TP ! Dans celui-ci, nous allons - enfin, vous allez - pouvoir réviser tout ce qui a été vu au cours de cette partie :

  • les fenêtres ;

  • les conteneurs ;

  • les boutons ;

  • les interactions ;

  • les classes internes ;

L'objectif est ici de réaliser une petite calculatrice basique.

Élaboration

Nous allons tout de suite voir ce dont notre calculatrice devra être capable :

  • Effectuer un calcul simple : 12 + 3 par exemple.

  • Faire des calculs à la chaîne, par exemple : 1 + 2 + ... ; lorsqu'on clique à nouveau sur un opérateur, il faut afficher le résultat du calcul précédent.

  • Donner la possibilité de tout recommencer à zéro.

  • Gérer l'exception d'une division par 0 !

Conception

Vous devriez obtenir à peu de choses près la figure suivante.

Notre calculatrice
Notre calculatrice

Voyons maintenant ce dont nous avons besoin pour parvenir à nos fins :

  • autant de boutons qu'il en faut ;

  • autant de conteneurs que nécessaire ;

  • unJLabelpour l'affichage ;

  • un booléen pour savoir si un opérateur a été sélectionné ;

  • un booléen pour savoir si nous devons effacer ce qui figure à l'écran et écrire un nouveau nombre ;

  • nous allons utiliser une variable de typedoublepour nos calculs ;

  • il va nous falloir des classes internes qui implémenteront l'interfaceActionListener;

  • et c'est à peu près tout.

Pour alléger le nombre de classes internes, vous pouvez en créer une qui se chargera d'écrire ce qui doit être affiché à l'écran. Utilisez la méthodegetSource()pour savoir sur quel bouton on a cliqué.

Je ne vais pas tout vous dire, il faut que vous cherchiez par vous-mêmes : la réflexion est très importante ! En revanche, vous devez savoir que la correction que je vous fournis n'est pas la correction. Il y a plusieurs solutions possibles. Je vous propose seulement l'une d'elles.

Allez, au boulot !

Correction

Vous avez bien réfléchi ? Vous vous êtes brûlé quelques neurones ? Vous avez mérité votre correction ! Regardez bien comment tout interagit, et vous comprendrez comment fonctionne ce code.

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
public class Calculatrice extends JFrame {
private JPanel container = new JPanel();
//Tableau stockant les éléments à afficher dans la calculatrice
String[] tab_string = {"1", "2", "3", "4", "5", "6", "7", "8", "9", "0", ".", "=", "C", "+", "-", "*", "/"};
//Un bouton par élément à afficher
JButton[] tab_button = new JButton[tab_string.length];
private JLabel ecran = new JLabel();
private Dimension dim = new Dimension(50, 40);
private Dimension dim2 = new Dimension(50, 31);
private double chiffre1;
private boolean clicOperateur = false, update = false;
private String operateur = "";
public Calculatrice(){
this.setSize(240, 260);
this.setTitle("Calculette");
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setLocationRelativeTo(null);
this.setResizable(false);
//On initialise le conteneur avec tous les composants
initComposant();
//On ajoute le conteneur
this.setContentPane(container);
this.setVisible(true);
}
private void initComposant(){
//On définit la police d'écriture à utiliser
Font police = new Font("Arial", Font.BOLD, 20);
ecran = new JLabel("0");
ecran.setFont(police);
//On aligne les informations à droite dans le JLabel
ecran.setHorizontalAlignment(JLabel.RIGHT);
ecran.setPreferredSize(new Dimension(220, 20));
JPanel operateur = new JPanel();
operateur.setPreferredSize(new Dimension(55, 225));
JPanel chiffre = new JPanel();
chiffre.setPreferredSize(new Dimension(165, 225));
JPanel panEcran = new JPanel();
panEcran.setPreferredSize(new Dimension(220, 30));
//On parcourt le tableau initialisé
//afin de créer nos boutons
for(int i = 0; i < tab_string.length; i++){
tab_button[i] = new JButton(tab_string[i]);
tab_button[i].setPreferredSize(dim);
switch(i){
//Pour chaque élément situé à la fin du tableau
//et qui n'est pas un chiffre
//on définit le comportement à avoir grâce à un listener
case 11 :
tab_button[i].addActionListener(new EgalListener());
chiffre.add(tab_button[i]);
break;
case 12 :
tab_button[i].setForeground(Color.red);
tab_button[i].addActionListener(new ResetListener());
operateur.add(tab_button[i]);
break;
case 13 :
tab_button[i].addActionListener(new PlusListener());
tab_button[i].setPreferredSize(dim2);
operateur.add(tab_button[i]);
break;
case 14 :
tab_button[i].addActionListener(new MoinsListener());
tab_button[i].setPreferredSize(dim2);
operateur.add(tab_button[i]);
break;
case 15 :
tab_button[i].addActionListener(new MultiListener());
tab_button[i].setPreferredSize(dim2);
operateur.add(tab_button[i]);
break;
case 16 :
tab_button[i].addActionListener(new DivListener());
tab_button[i].setPreferredSize(dim2);
operateur.add(tab_button[i]);
break;
default :
//Par défaut, ce sont les premiers éléments du tableau
//donc des chiffres, on affecte alors le bon listener
chiffre.add(tab_button[i]);
tab_button[i].addActionListener(new ChiffreListener());
break;
}
}
panEcran.add(ecran);
panEcran.setBorder(BorderFactory.createLineBorder(Color.black));
container.add(panEcran, BorderLayout.NORTH);
container.add(chiffre, BorderLayout.CENTER);
container.add(operateur, BorderLayout.EAST);
}
//Méthode permettant d'effectuer un calcul selon l'opérateur sélectionné
private void calcul(){
if(operateur.equals("+")){
chiffre1 = chiffre1 +
Double.valueOf(ecran.getText()).doubleValue();
ecran.setText(String.valueOf(chiffre1));
}
if(operateur.equals("-")){
chiffre1 = chiffre1 -
Double.valueOf(ecran.getText()).doubleValue();
ecran.setText(String.valueOf(chiffre1));
}
if(operateur.equals("*")){
chiffre1 = chiffre1 *
Double.valueOf(ecran.getText()).doubleValue();
ecran.setText(String.valueOf(chiffre1));
}
if(operateur.equals("/")){
try{
chiffre1 = chiffre1 /
Double.valueOf(ecran.getText()).doubleValue();
ecran.setText(String.valueOf(chiffre1));
} catch(ArithmeticException e) {
ecran.setText("0");
}
}
}
//Listener utilisé pour les chiffres
//Permet de stocker les chiffres et de les afficher
class ChiffreListener implements ActionListener {
public void actionPerformed(ActionEvent e){
//On affiche le chiffre additionnel dans le label
String str = ((JButton)e.getSource()).getText();
if(update){
update = false;
}
else{
if(!ecran.getText().equals("0"))
str = ecran.getText() + str;
}
ecran.setText(str);
}
}
//Listener affecté au bouton =
class EgalListener implements ActionListener {
public void actionPerformed(ActionEvent arg0){
calcul();
update = true;
clicOperateur = false;
}
}
//Listener affecté au bouton +
class PlusListener implements ActionListener {
public void actionPerformed(ActionEvent arg0){
if(clicOperateur){
calcul();
ecran.setText(String.valueOf(chiffre1));
}
else{
chiffre1 = Double.valueOf(ecran.getText()).doubleValue();
clicOperateur = true;
}
operateur = "+";
update = true;
}
}
//Listener affecté au bouton -
class MoinsListener implements ActionListener {
public void actionPerformed(ActionEvent arg0){
if(clicOperateur){
calcul();
ecran.setText(String.valueOf(chiffre1));
}
else{
chiffre1 = Double.valueOf(ecran.getText()).doubleValue();
clicOperateur = true;
}
operateur = "-";
update = true;
}
}
//Listener affecté au bouton *
class MultiListener implements ActionListener {
public void actionPerformed(ActionEvent arg0){
if(clicOperateur){
calcul();
ecran.setText(String.valueOf(chiffre1));
}
else{
chiffre1 = Double.valueOf(ecran.getText()).doubleValue();
clicOperateur = true;
}
operateur = "*";
update = true;
}
}
//Listener affecté au bouton /
class DivListener implements ActionListener {
public void actionPerformed(ActionEvent arg0){
if(clicOperateur){
calcul();
ecran.setText(String.valueOf(chiffre1));
}
else{
chiffre1 = Double.valueOf(ecran.getText()).doubleValue();
clicOperateur = true;
}
operateur = "/";
update = true;
}
}
//Listener affecté au bouton de remise à zéro
class ResetListener implements ActionListener {
public void actionPerformed(ActionEvent arg0){
clicOperateur = false;
update = true;
chiffre1 = 0;
operateur = "";
ecran.setText("");
}
}
}
public class Main {
public static void main(String[] args) {
Calculatrice calculette = new Calculatrice();
}
}

Je vais vous donner une petite astuce afin de créer un.jarexécutable en Java.

Générer un .jar exécutable

Tout d'abord, qu'est-ce qu'un.jar ? C'est une extension propre aux archives Java (JavaARchive). Ce type de fichier contient tout ce dont a besoin la JVM pour lancer un programme. Une fois votre archive créée, il vous suffit de double-cliquer sur celle-ci pour lancer l'application. C'est le meilleur moyen de distribuer votre programme.

La création d'un.jarest un jeu d'enfant. Commencez par effectuer un clic droit sur votre projet et choisissez l'optionExport, comme le montre la figure suivante.

Exporter son projet
Exporter son projet

Vous voici dans la gestion des exports. Eclipse vous demande quel type d'export vous souhaitez réaliser, comme à la figure suivante.

Type d'export à choisir
Type d'export à choisir

Comme l'illustre la figure précédent, sélectionnezJAR Filepuis cliquez surNext. Vous voici maintenant dans la section qui vous demande les fichiers que vous souhaitez inclure dans votre archive, comme à la figure suivante.

Choix des fichiers à inclure
Choix des fichiers à inclure
  • Dans le premier cadre, sélectionnez tous les fichiers qui composeront votre exécutable.jar.

  • Dans le second cadre, indiquez à Eclipse l'endroit où créer l'archive et le nom vous souhaitez lui donner.

  • Ensuite, cliquez surNext.

La page suivante n'est pas très pertinente ; je la mets cependant en figure suivante afin de ne perdre personne.

Choix du niveau d'erreurs tolérable
Choix du niveau d'erreurs tolérable

Cliquez surNext: vous arrivez sur la page qui vous demande de spécifier l'emplacement de la méthodemaindans votre programme (figure suivante).

Choix du point de départ du programme
Choix du point de départ du programme

Cliquez surBrowse…pour afficher un pop-up listant les fichiers des programmes contenant une méthodemain. Ici, nous n'en avons qu'une (voir figure suivante). Souvenez-vous qu'il est possible que plusieurs méthodesmainsoient déclarées, mais une seule sera exécutée !

Notre méthode main
Notre méthode main

Sélectionnez le point de départ de votre application et validez. La figure suivante correspond à ce que vous devriez obtenir.

Récapitulatif d'export
Récapitulatif d'export

Vous pouvez maintenant cliquer surFinishet voir s'afficher un message ressemblant à celui de la figure suivante.

Message lors de l'export
Message lors de l'export

Ce type de message n'est pas alarmant : il vous signale qu'il existe des éléments qu'Eclipse ne juge pas très clairs. Ils n'empêcheront toutefois pas votre application de fonctionner, contrairement à un message d'erreur que vous repérerez facilement : il est en rouge.

Une fois cette étape validée, vous pouvez voir avec satisfaction qu'un fichier.jara bien été généré dans le dossier spécifié, comme à la figure suivante.

Fichier exécutable .jar
Fichier exécutable .jar

Double-cliquez sur ce fichier : votre calculatrice se lance !

Exemple de certificat de réussite
Exemple de certificat de réussite