Bonsoir à tous (et joyeux noël),

Voila, étant un grand débutant en Java et en POO (par la même occasion), il se trouve que j'ai rencontré quelques problèmes avec le TP de la calculatrice...
Je pense que c'est plus un problème d'algorithmique, je ne comprend pas très bien le fonctionnement de celle-ci (notamment avec une suite d'opérations...) pourtant j'ai bien relu les chapitres précédents et analysé le code mais rien n'y fait.

Voici le code tout d'abord de ce TP:

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("");
                }
                
        }
        
}

Le début, ça va, il créé les boutons, les classe dans un tableau, ... aussi, les variables booléennes (je comprend déjà pas bien leur utilité et leurs interactions par la suite).
Ensuite, il configure la fenêtre du programme, aucun souci.
Il crée des sous-panels pour mieux aligner les boutons des chiffres, des opérations,...
Ensuite à partir de là, il configure la taille des différents boutons, les insère dans les sous panels, ensuite à partir de là, je lâche complètement pour la fonction calcul, je comprend pas du tout comment tout cela interagit (aussi avec les calculs en chaîne genre 10+20-10/45...)


Désolé pour mon noobisme
Bonne soirée.

pour les calcules il ne fait pas d'opération en chaine justement °-0
je t'explique

donc il à créé une variable pour l'objet qui s'appel opérateur qui contiendra toujours le dernier opérateur sur lequel on a cliqué okay ? ainsi quand on cliquera sur "égale" il n'aura plus qu'a prendre la valeur précédente, l'additionner avec la valeur actuelle qui se trouve dans "la zone de texte"

donc a chaque fois que tu clic sur un opérateur, il fait l'opération précédente, il stoque le résultat dans la variable prévue a cet effet et change la variable opérateur, pour qu'elle prenne la valeur de l'opérateur suivant

exemple
tu rentre
d'abord tu tapes 10
rien n'est stocker pour l'instant (entre guillemets )
puis +
il assigne à sa variable "chiffre1" la valeur 10
il assigne à la variable "operateur" la valeur "+"

tu rentre 20
chiffre 1 vaut toujours "10" et opérateur "+"
tu clic sur un autre opérateur genre "-" cette fois

La il calcule la nouvelle valeur de chiffre1
Comme l'opérateur vaut "+" (méthode calcul operateur.equals("+") )
il fait
chiffre1 = chiffre1 + 20; donc maintenant chiffre1 vaut 30
ensuite seulement il assigne à la variable "operateur" la valeur "-"

voilà ... il attend la suite ext ext ext ...

quand tu clic sur reset l'opérateur redeviens "" et donc a l'appel suivant de calcul tous recommence

Salut,
Je suis moi aussi débutant et je m'interroge sur l'appet de la méthode calcul()dans les classe implémentées. Exemple,
pourquoi l'appel de cette méthose de ce fait pas de cette manière calcul().PlusListener ?
merci

°_0 hein ?
tu ferais bien de relire la partie sur les listener toi -_-' c'est le listener qui appel la fonction calcul() ....
quand tu pousse sur un bouton plus par exemple ...
sur le bouton plus on y a mis le Listener "PlusListener"
quand tu clic sur le bouton "+"
tu appels la méthode

public void actionPerformed(ActionEvent arg0)

de pluslistener
soit la fonction

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;
                }

tu vois bien que dans cette fonction on fait deux chose soit on a cliqué sur un opérateur avant donc chiffre1 a déjà une valeur ... la on appel la méthode calcul qui vas recalculer sa nouvelle valeurs
soit on oublie la valeurs qu'avait chiffre1 et on lui stocker une nouvelle valeurs sans calcules

Salut,
Merci mais j'avais bien compris que le listener appelait la fonction calcul, mais pourquoi pas de cette manière : ?
calcul().PlusListener

....
je comprend pas ta question -_-'
calcul() est de type void .... il ne renvois rien ...
je comprend donc pas pourquoi tu écris calcul().qqch ...
en plus le PlusListener est une class ....

peut être ferais tu mieux de relire tous le tutoriel en vitesse ... voir si tu as tout bien compris >.<

sauf erreur de ma part -_-' mais bon

Salut,
Effectivement il est probable que tout n'est pas parfaitement compris et je n'hésite pas à retourner régulièrement sur le tutorel .Néanmoins je sais qu'une méthode void ne retourne rien.Mais lorsque je l'appel dans la classe main nommée lulu par exemple, pour l'afficher je fais de cette manière :
si la méthode appartient à un objet facture je saisis facture.affiche()
si cette méthode est déclarée static je saisis lulu.affiche().
or, dans notre cas la fonction void est appelée par une classe implémenté.C'est pourquoi je serais tenté de l'appler de la manière suivante dans le cas d'un appui sur le bouton + : PlusListener.calcul()
merci

ha mieux -_-'
tu écrivais calcul().PlusListener ...
càd l'inverse de maintenant -_-'

bon tu le remarqueras les class Listener sont déclarée dans l'objet Calculette! d'accord ?

note simplement que quand c'est comme ça elle peuvent faire appels au variable ou aux fonction (non déclarée private) de l'objet dans lequel elle à été créée

c'est comme si de la class Calculette j'appelais la méthode calcul.

en vérité c'est plus compliqué mais c'est pour simplifié
normalement tu dois faire LACaluclette.calcul();
pour dire que c'est cet objet la qui dois faire appel a sa fonction calcule
mais quand tu fais calcul() dans le listener, java traduis ça par "L'objetdanslequelestcontenusceListener.calcul();"
essaye de faire this.Calcule(); normalement ça devrait te renvoyer une erreur
parce que le this renvois a l'objet PlusListener mais le PlusListener ne contiens pas de fonction Calcul();