[Plan du site] Vous êtes ici --- > Le Site du Zéro > Les tutoriels > Officiels > Programmation > Programmation en Java > Java et la programmation événementielle > TP : une calculatrice > Lecture du tutoriel

TP : une calculatrice

Ah ! Ça faisait longtemps... un petit TP...

Dans celui-ci, nous allons - enfin vous allez - pouvoir réviser tout ce que vous avez appris dans cette partie !

Fenetre
Conteneur
Bouton
ActionPerformed
Classe interne
Exception. Bon, ça, c'était dans celle d'avant.

Allez mes ZérOs, en avant !

Sommaire du chapitre :

Élaboration
Conception
Correction
Astuce Eclipse : faire un jar exécutable

Élaboration

Bon, nous allons voir ce que doit faire notre calculatrice.

Un calcul simple : 12 + 3 =
Des calculs à la chaîne... Exemple : 1 + 2 +, lorsque vous cliquez à nouveau sur un opérateur, vous affichez le résultat du calcul précédent !
Donner la possibilté de faire un reset, donc de tout faire recommencer à zéro.
Gérer l'exception pour une division par 0 !

Conception

Voilà ce que vous devriez avoir :

Maintenant, voyons ce dont nous avons besoin pour réussir ça.

Autant de boutons qu'il en faut.
Autant de conteneurs que nécessaire.
Un JLabel pour l'affichage.
Un booléen pour savoir si un opérateur a été choisi.
Un booléen pour savoir si nous devons effacer ce qu'il y a à l'écran et écrire un nouveau nombre.
Nous allons utiliser une variable de type double pour nos calculs.
Il va falloir des classes internes qui implémenteront l'interface ActionListener.
Et c'est à peu près tout...

Pour alléger le nombre de classes internes, vous pouvez en faire une qui va se charger d'écrire ce qui doit être affiché à l'écran.
Utiliser la méthode getSource() pour savoir de quel bouton il s'agit...

Je ne vais pas tout vous dire... Il faut que vous cherchiez par vous-mêmes... La réflexion est très bonne !
Par contre, je vous le dis tout de suite :

la correction que je vous fournis n'est pas LA correction.
Il n'y a pas de bonne solution : si, en fait, considérez un programme qui fonctionne comme une solution.
Je vous propose seulement une solution POSSIBLE.

Allez, en avant mes ZérOs !

Correction

Vous avez bien réfléchi ?
Vous vous êtes brûlé quelques neurones... Vous avez mérité votre correction...

Secret (cliquez pour afficher)

Classe Main.java

Code : Java

public class Main {
 
        /**
         * @param args
         */
        public static void main(String[] args) {
                Calculatrice calculette = new Calculatrice();
 
        }
 
}

Classe Calculatrice.java

Code : Java

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();
        
        String[] tab_string = {"1", "2", "3", "4", "5", "6", "7", "8", "9", "0", ".", "=", "C", "+", "-", "*", "/"};
        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);
                initComposant();
                
                this.setContentPane(container);
                this.setVisible(true);
        }
        
        private void initComposant(){

                Font police = new Font("Arial", Font.BOLD, 20);
                ecran = new JLabel("0");
                ecran.setFont(police);
                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));

                
                for(int i = 0; i < tab_string.length; i++)
                {
                    
                    tab_button[i] = new JButton(tab_string[i]);
                    tab_button[i].setPreferredSize(dim);
                    
                    switch(i){
	                
                    	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 :
                    		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);
                
        }
        
        
        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");
                        }
                }
        }
        
        class ChiffreListener implements ActionListener{
 
                @Override
                public void actionPerformed(ActionEvent e) {
                        //On affiche le chiffre en plus 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);
                }
                
        }
 
        
        class EgalListener implements ActionListener{
 
                @Override
                public void actionPerformed(ActionEvent arg0) {
                        calcul();
                        update = true;
                        clicOperateur = false;
                }
                
        }
        
        
        class PlusListener implements ActionListener{
 
                @Override
                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;
                }
                
        }
        
        class MoinsListener implements ActionListener{
 
                @Override
                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;
                }
                
        }
        
        
        class MultiListener implements ActionListener{
 
                @Override
                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;
                }
                
        }
        
        
        class DivListener implements ActionListener{
 
                @Override
                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;
                }
                
        }
        
        
        class ResetListener implements ActionListener{
 
                @Override
                public void actionPerformed(ActionEvent arg0) {
                        clicOperateur = false;
                        update = true;
                        chiffre1 = 0;
                        operateur = "";
                        ecran.setText("");
                }
                
        }
        
}

Je ne m'attarderai pas trop là-dessus, ce code est très simple et je suis sûr que vous trouverez des améliorations

.
Regardez bien comment tout interagit, et vous comprendrez comment il fonctionne !

Je vais vous donner une petite astuce pour faire un .jar exécutable en java...

Astuce Eclipse : faire un jar exécutable

Tout d'abord, qu'est-ce qu'un .jar ?
Un tel fichier est une archive Java (Java ARchive). Ce type de fichier contient tout ce dont a besoin la JVM pour lancer votre programme ! Une fois votre archive créée, il vous suffira juste de double cliquer sur celle-ci pour lancer l'application ! :magicien:

Ceci sous réserve que vous ayez ajouté les exécutables de votre JRE (présent dans le répertoire /bin) dans votre variable d'environnement PATH !
Si ceci n'est pas fait, allez faire un tour ici en remplaçant le répertoire du JDK par celui du JRE (si vous n'avez pas téléchargé le JDK, sinon, prenez ce dernier...).

Vous allez voir que créer un .jar est très simple !
Commencez par faire un clic droit sur votre projet et choisissez l'option Export, comme ceci :

Vous voici dans la gestion des exports. Eclipse vous demande quel type d'export vous souhaitez faire :

Comme sur l'image ci-dessus, ssélectionnez JAR File et cliquez sur Next. Vous voici maintenant dans le section qui vous demande quels fichiers vous voulez mettre dans votre archive.

Dans le cadre vert, nous choisissons tous les fichiers qui composeront notre exécutable .jar.
Dans le cadre bleu, nous spécifions à eclipse où créer l'archive et quel nom elle doit avoir.
Ensuite... On clique sur Next.

La page suivante n'est pas pertinente ici. Allez hop ! Circulez, y a rien à voir... (Il manque une émoticône gendarme sur le SDZ...)

La voici tout de même :

Cliquez sur Next et nous arrivons sur la page qui va nous demander où se trouve la méthode main dans notre programme :

Cliquez sur Browse... ; vous êtes maintenant sur une petite popup qui liste les fichiers de programmes contenant une méthode main. Ici, nous n'en avons qu'un... Mais il est possible d'avoir plusieurs méthodes main déclarées MAIS SEULEMENT UNE SEULE SERA EXÉCUTÉE !

Sélectionnez le point de départ de votre application et validez !
Voici ce que nous avons :

Vous pouvez maintenant cliquez sur Finish et vous devriez avoir un message du genre...

Ce type de message n'est pas alarmant ! Celui-ci vous dit qu'il existe des choses qu'Eclipse ne juge pas très claires... Mais celles-ci n'empêcheront pas votre application de fonctionner... Contrairement à un message d'erreur... Mais là, vous allez le repérer... Il est rouge.

Une fois cette étape validée, vous pouvez voir avec joie, qu'un fichier .jar a bien été généré dans le dossier spécifié !

Double cliquez sur lui et votre calculatrice se lance ! :magicien:

Si vous voulez en savoir plus sur les fichiers .jar, je vous recommande le tuto de bartimeus.

J'espère que ce TP vous a plu !
Je vous le répète encore une fois, mais mon code est loin d'être parfait et vous pouvez vous y attarder pour l'améliorer !

Par exemple, vous pourriez créer un objet dont la fonction est de faire les calculs...
Vous pourriez aussi faire une calculette avec plus de fonctionnalités ! Enfin, vous voyez quoi...

Bon, continuons notre tuto. Nous en étions restés au problème de thread évoqué lorsque nous avions essayé de relancer notre animation.
Je pense que vous avez deviné la suite, en avant pour : les threads.

Tutoriels

Communauté

Mon compte

Recherche

Livre d'or

Publicité