Partage
  • Partager sur Facebook
  • Partager sur Twitter

la Calculatrice

partagez le problème en plusieurs classes

Sujet résolu
    30 mars 2011 à 4:26:26

    Bonjour les Zeros, :)

    Je voudrais faire une calculatrice comme celle du tutoriel, mais en plusieurs classes, par exemple 4 classe de JPanel:

    -un JPanel pour les chiffres.
    -un Jpanel pour les opérateurs.
    -un JPanel pour l'ecran.
    -et enfin un autre pour les boutons clear, backspace, enter...


    j'ai deja commencé, mais je ne sais pas comment interagir les classes entre elle, par exemple,
    comment afficher le contenu de la classe des chiffre dans l'ecran, qui se trouve en fait dans une autre classe?

    • Partager sur Facebook
    • Partager sur Twitter
      30 mars 2011 à 10:08:56

      Bonjour.

      Dans le cas d'un découpage en plusieurs classes, il faut penser à mettre en place des accès au élément depuis l'extérieur. Ça peut ce traduire par une accessibilité package des élément en mettant toute les classe de l'IHM dans le même package.

      Après en théorie il fadrais, si la classe A agit sur B, que A contient une référence de B. Et si C agis sur A, que C contienne A. Et ainsi de suite.

      Une autre méthode bien plus propre est de définir un manageur. Une classe qui comprend toute les instance des autre classe. Dans le cas des JPanel, la JFrame peut convenir, mais on peut aussi imaginer une autre classe externe.
      Tu fait donc en sorte que le manageur puisse correctement modifier les JPanel, puis tu crée des méthode d'intéraction (ajouterChiffre(int chiffre), effacer(), effectuerCalcul(), ect...).
      Ensuite tu passe le manageur en paramètre à tes ActionListener. Les evènement déclencheront les méthode du manageur qui se chargera de la communication entre les élément de l'IHM.

      En gros ça ressemblerai à ça :
      UML Manager IHM

      Pour plus d'info sur la représentation, UML : chapitre 2.3. de ton tuto.

      Dans l'absolut, pour un petit TP comme la calculatrice on peut même simplifier en créant un ActionListener unique et externe qui jouera le rôle de manageur.


      • Partager sur Facebook
      • Partager sur Twitter
        30 mars 2011 à 17:55:56

        En gros voici mes classes:

        celle qui contient le main:
        import javax.swing.*;
        import java.awt.*;

        public class CalculatorJFrame extends JFrame
        {
        public static void main(String[] args)
        {
        new CalculatorJFrame();
        }

        public CalculatorJFrame()
        {
        setTitle("La calculatrice de Meryama");
        setLayout(new BorderLayout());
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLocationRelativeTo(null);
        setResizable(true);

        CalculatorType calculator = new CalculatorType();

        NorthJPanel northJPanel = new NorthJPanel();
        JLabel topLabel = northJPanel.getTopLabel();

        getContentPane().add( northJPanel, BorderLayout.NORTH);
        getContentPane().add( new CenterJPanel( topLabel ), BorderLayout.CENTER);
        getContentPane().add( new EastJPanel( topLabel, calculator), BorderLayout.EAST);
        getContentPane().add( new SouthJPanel(topLabel, calculator), BorderLayout.SOUTH);

        pack();
        setVisible(true);
        }

        }


        -le JPanel qui contiendra l'ecran:
        import javax.swing.*;
        import java.awt.*;

        public class NorthJPanel extends JPanel
        {
        private JLabel topLabel = new JLabel("0");

        public NorthJPanel()
        {
        initComposants();

        }

        private void initComposants()
        {
        topLabel.setPreferredSize(new Dimension(340,35));
        this.add(topLabel);
        topLabel.setHorizontalAlignment(JLabel.RIGHT);
        setBorder(BorderFactory.createLineBorder(Color.BLUE, 5));

        }

        public JLabel getTopLabel()
        {
        return topLabel ;
        }

        public void setTopLabel(JLabel topLabel)
        {

        }
        }

        -le JPanel qui contiendra les chiffres:
        import java.awt.event.*;
        import javax.swing.*;
        import java.awt.*;

        public class CenterJPanel extends JPanel
        {
        String str[] = {"1","2","3","4","5","6","7","8","9",".","0","bs"};
        JButton numbers[] = new JButton[str.length];
        private boolean update = false;
        private JLabel topLabel = new JLabel();

        public CenterJPanel()
        {
        initComposants();

        }

        public CenterJPanel(JLabel topLabel)
        {
        initComposants();
        }

        private void initComposants()
        {

        setLayout(new GridLayout (4, 3, 5, 5));
        setBackground(Color.CYAN);
        setBorder(BorderFactory.createLineBorder(Color.BLUE, 5));

        for (int i = 0 ; i < str.length ; i++)
        {
        numbers[i] = new JButton(str[i]);
        numbers[i].setPreferredSize(new Dimension(65,35));
        this.add(numbers[i]);
        if(i == 9)
        numbers[i].addActionListener(new DecimalListener());
        else if(i == 11)
        numbers[i].addActionListener(new BSListener());
        else
        numbers[i].addActionListener(new NumberListener());
        }
        }

        class NumberListener implements ActionListener
        {
        public void actionPerformed (ActionEvent e)
        {
        String str = ((JButton)e.getSource()).getText();
        if(update)
        update = false;
        else
        {
        if(!topLabel.getText().equals("0"))
        str = topLabel.getText() + str;
        }
        topLabel.setText(str);

        }
        }

        class DecimalListener implements ActionListener
        {
        public void actionPerformed(ActionEvent e)
        {

        }
        }

        class BSListener implements ActionListener
        {
        public void actionPerformed(ActionEvent e)
        {

        }
        }

        }

        -le JPanel qui contiendra les opérateurs:
        import javax.swing.*;
        import java.awt.event.*;
        import java.awt.*;

        public class SouthJPanel extends JPanel
        {
        String str[] = {"+/-","+","-","*","/","1/x"};
        JButton operators[] = new JButton[str.length];

        public SouthJPanel()
        {
        initComposants();
        }

        public SouthJPanel(JLabel topLabel, CalculatorType Calculator)
        {
        initComposants();
        }

        private void initComposants()
        {
        setPreferredSize(new Dimension(30,50));
        setLayout(new GridLayout(1,5,5,5));
        setBackground(Color.CYAN);
        setBorder(BorderFactory.createLineBorder(Color.BLUE, 5));
        for(int i = 0; i < str.length; i++)
        {
        operators[i] = new JButton(str[i]);
        operators[i].setPreferredSize(new Dimension(50,30));
        this.add(operators[i]);
        if(i == 1)
        operators[i].addActionListener(new PlusListener());
        else if(i == 2)
        operators[i].addActionListener(new MinesListener());
        else if(i == 3)
        operators[i].addActionListener(new MultiListener());
        else if(i == 4)
        operators[i].addActionListener(new DivisionListener());

        }

        }

        class PlusListener implements ActionListener
        {
        public void actionPerformed(ActionEvent e)
        {

        }
        }

        class MinesListener implements ActionListener
        {
        public void actionPerformed(ActionEvent e)
        {

        }
        }

        class MultiListener implements ActionListener
        {
        public void actionPerformed(ActionEvent e)
        {

        }
        }

        class DivisionListener implements ActionListener
        {
        public void actionPerformed(ActionEvent e)
        {

        }
        }
        }

        -le JPanel qui contienra les boutons comme exit, restart...
        import java.awt.event.ActionListener;
        import java.awt.event.ActionEvent;
        import java.awt.*;
        import javax.swing.*;

        public class EastJPanel extends JPanel
        {
        private String str[] = {"Clear","Enter","Restart","Exit"};
        private JButton east[] = new JButton[str.length];
        private CalculatorType calculator = new CalculatorType();

        public EastJPanel()
        {
        initComposants();
        }

        public EastJPanel(JLabel tobLabel, CalculatorType Calculator)
        {
        initComposants();
        }

        private void initComposants()
        {
        setLayout(new GridLayout (4, 1, 5, 5));
        setBackground(Color.CYAN);
        setBorder(BorderFactory.createLineBorder(Color.BLUE, 5));

        for(int i = 0; i < str.length; i++)
        {
        east[i] = new JButton(str[i]);
        east[i].setPreferredSize( new Dimension(140, 35));
        this.add(east[i]);

        if(i == 0)
        east[i].addActionListener(new ClearListener());
        else if (i == 1)
        east[i].addActionListener(new EnterListener());
        else if (i == 2)
        east[i].addActionListener(new RestartListener());
        else if (i == 3)
        east[i].addActionListener(new ExitListener());

        }
        }

        class EnterListener implements ActionListener
        {
        public void actionPerformed(ActionEvent e)
        {

        }
        }

        class ExitListener implements ActionListener
        {
        public void actionPerformed(ActionEvent e)
        {

        }
        }

        class ClearListener implements ActionListener
        {
        public void actionPerformed(ActionEvent e)
        {

        }
        }

        class RestartListener implements ActionListener
        {
        public void actionPerformed(ActionEvent e)
        {

        }
        }
        }

        -et enfin, la classe qui fais les calcul:
        import java.text.DecimalFormat;
        import javax.swing.*;

        public class CalculatorType
        {
        private double[ ] memory;
        private int topIndex;


        public CalculatorType( )
        {
        memory = new double[ 10 ];
        topIndex = -1;
        }

        public void enter( double number )
        {
        if (topIndex < 9)
        {
        topIndex++;
        memory[ topIndex ] = number;
        }
        else
        {
        JOptionPane.showMessageDialog(null, "Calculator error: capacity exceded!" );
        }
        }

        public void clear( )
        {
        topIndex = -1;
        }

        public void negate( )
        {
        if (topIndex >= 0 && topIndex < 10)
        {
        memory[ topIndex ] = -memory[ topIndex ];
        }
        }

        public void add( )
        {
        if (topIndex > 0 && topIndex < 10)
        {
        memory[ topIndex-1 ] += memory[ topIndex ];
        topIndex--;
        }
        }

        public void subtract( )
        {
        if (topIndex > 0 && topIndex < 10)
        {
        memory[ topIndex-1 ] -= memory[ topIndex ];
        topIndex--;
        }
        }

        public void multiply( )
        {
        if (topIndex > 0 && topIndex < 10)
        {
        memory[ topIndex-1 ] *= memory[ topIndex ];
        topIndex--;
        }
        }

        public void divide( )
        {
        if (topIndex > 0 && topIndex < 10)
        {
        if (memory[topIndex] != 0.0)
        {
        memory[ topIndex-1 ] = memory[ topIndex-1 ]/ memory[ topIndex ];
        topIndex--;
        }
        else
        JOptionPane.showMessageDialog(null, "Error - division by zero" );
        }
        }

        public void invert( )
        {
        if (topIndex >= 0 && topIndex < 10)
        {
        if ( memory[ topIndex ] != 0.0 )
        memory[ topIndex ] = 1.0 / memory[ topIndex ];
        else
        JOptionPane.showMessageDialog(null, "Error - division by zero" );
        }
        }

        public String toString( )
        {
        if (topIndex == -1)
        {
        return "";
        }
        if (Math.abs( memory[ topIndex ] ) < 0.00000000000000000001)
        {
        return "0.0";
        }
        DecimalFormat fmt = new DecimalFormat("0.##############" );
        return fmt.format( memory[ topIndex ] );
        }
        }


        Je cherche a faire une calculatrice en notation Polonaise inversé, c'est a dire en gros que si on veut calculer 1+2, on devra taper 1, Enter, 2, Enter, +, Enter!


        Comme vous pouvez le voir, ce n'est pas encore complet, et je ne sais pas comment le compléter, c'est surtout au niveau de ActionListener que je bloque, et aussi au niveau de l'affichage sur l'ecran.


        Merci de votre aide!!
        :)
        • Partager sur Facebook
        • Partager sur Twitter
          30 mars 2011 à 18:51:18

          Le plus simple est d'utiliser une variable tampon en string.
          Quand tu appuies sur une touche, tu ajoute le chiffre à ta string et tu met l'affichage à jour.
          Quand tu appuies sur entrée, tu fait un Double.parse(tampon) pour récupérer ton double tu l'enregistre dans la classe de calcul et tu vide la variable tampon.

          Après pour l'opérateur t'as juste à le tester pour choisir ton calcul.

          Pense juste à faire en sorte que ton affichage soit visible depuis les ActionListner qui sont susceptible de le modifier (chiffre, opérateur, entrée);
          • Partager sur Facebook
          • Partager sur Twitter
            31 mars 2011 à 1:47:20

            Ma question est juste comment acceder à la classe NorthJPanel qui contient notre ecran, pour pouvoir mettre l'ecran à jour a chaque fois.
            je ne peux pas mettre ecran.setText() parce que ce n'est pas defini dans ma classe, alors comment y acceder?
            • Partager sur Facebook
            • Partager sur Twitter
              31 mars 2011 à 13:18:48

              Il faut la passer en paramètre aux classe qui en on besoin, comme j'ai dit plus haut.

              par exemple dans le cas du pan des chiffre :


              import java.awt.event.*;
              import javax.swing.*;
              import java.awt.*;
              
              public class CenterJPanel extends JPanel 
              {
              
              // Ecran en attribut
                  NorthJPanel ecran;
              
                  String str[] = {"1","2","3","4","5","6","7","8","9",".","0","bs"};
                  JButton numbers[] = new JButton[str.length];
                  private boolean update = false;
                  private JLabel topLabel = new JLabel();
                  
                  public CenterJPanel()
                  {
                      initComposants();
              
                  }
                  
                  public CenterJPanel(JLabel topLabel)
                  {
                      initComposants();
                  }
              
              // Constructeur permettant le passage de l'écran en paramètre
                  public CenterJPanel(JLabel topLabel, NorthJPanel ecran)
                  {
                      initComposants();
                      this.ecran = ecran;
                  }
                  
                  private void initComposants()
                  {
                      
                 ..................
              


              import javax.swing.*;
              import java.awt.*;
              
              public class CalculatorJFrame extends JFrame 
              {
                 public static void main(String[] args)
                 {
                     new CalculatorJFrame();
                 }
                 
                 public CalculatorJFrame()
                 {
                    setTitle("La calculatrice de Meryama");     
                    setLayout(new BorderLayout());
                    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                    setLocationRelativeTo(null);
                    setResizable(true);
                    
                    CalculatorType calculator = new CalculatorType();
              
                    NorthJPanel northJPanel = new NorthJPanel();
                    JLabel topLabel = northJPanel.getTopLabel();     
                    
                    getContentPane().add( northJPanel, BorderLayout.NORTH);
              // Ajout de l'écran à la création du panel
                    getContentPane().add( new CenterJPanel( topLabel, northJPanel ), BorderLayout.CENTER); 
                    getContentPane().add( new EastJPanel( topLabel, calculator),  BorderLayout.EAST); 
                    getContentPane().add( new SouthJPanel(topLabel, calculator),  BorderLayout.SOUTH); 
              
                    pack();
                    setVisible(true);
                 }
                 
              }
              


              Comme tu peut le voir, j'ai ajouter le NorthJPanel en attribut et defini un nouveau constructeur.
              Dans la frame ensuite je passe le NorthJPanel en paramètre au constructeur du CenterJPanel. De là, le CenterJPanel peut agir sur le NorthJPanel.
              Même délire avec les listener, au sain du CenterJPanel.
              • Partager sur Facebook
              • Partager sur Twitter
                5 avril 2011 à 3:32:23

                :( Ca ne marche toujours pas!!
                ca fait une semaine que je suis en train d'essayer mais en vain!
                est-ce-que quelqu'un pourrait m'aider un peu sur ce code? :-°
                • Partager sur Facebook
                • Partager sur Twitter
                  5 avril 2011 à 13:52:11

                  Ben juste en l'état dans le quel je te l'ai donné c'est normal.
                  Après faut voir ce que tu as implémenté comme méthode dans tes Listener.

                  Un simple "ça marche pas" n'est pas suffisant pour un debuggage. ^^
                  • Partager sur Facebook
                  • Partager sur Twitter
                    5 avril 2011 à 17:12:56

                    Justement je ne sais pas quoi faire la dedans!
                    et en fait tu fait appel a l'écran deux foix, va voir la class main, j'ai deja fait appel a l'ecran alors il faut pas le faire une 2ème fois!
                    • Partager sur Facebook
                    • Partager sur Twitter
                      8 avril 2011 à 8:15:47

                      Tu est dans 2 classe différante. Alors oui il faut 2 enregistrement, pour chacune d'elle.
                      Mais dans le CentralJPanel on ne fait pas de new.
                      On utilise l'objet NorthJPanel créer dans la JFrame.
                      On utilise donc le même écran dans les 2 classes.
                      Je vais essayer de te faire un exemple complet si j'ai le temps.

                      Edit : Je viens de capter à quoi correspond le topLabel.
                      Donc en fait dans ce cas on à pas besoin de passer le CenterJPanel.
                      Mais je vais quand même le faire, car en fin de compte c'est plus pratique. On peut prédéfinir des méthode d'affichage.

                      Edit2 : Voici l'exemple avec le CenterJPanel
                      import javax.swing.*;
                      import java.awt.*;
                      
                      public class CalculatorJFrame extends JFrame 
                      {
                          public static void main(String[] args){
                              new CalculatorJFrame();
                          }
                      
                          public CalculatorJFrame(){
                              setTitle("La calculatrice de Meryama"); 
                              setLayout(new BorderLayout());
                              setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                              setLocationRelativeTo(null);
                              setResizable(true);
                      
                              CalculatorType calculator = new CalculatorType();
                      
                              NorthJPanel northJPanel = new NorthJPanel();
                              JLabel topLabel = northJPanel.getTopLabel(); 
                      
                              getContentPane().add( northJPanel, BorderLayout.NORTH);
                              getContentPane().add( new CenterJPanel( northJPanel ), BorderLayout.CENTER); 
                              getContentPane().add( new EastJPanel( topLabel, calculator), BorderLayout.EAST); 
                              getContentPane().add( new SouthJPanel(topLabel, calculator), BorderLayout.SOUTH); 
                      
                              pack();
                              setVisible(true);
                          }
                      
                      }
                      

                      import javax.swing.*;
                      import java.awt.*;
                      import java.util.regex.Pattern;
                      
                      public class NorthJPanel extends JPanel{
                          
                          private JLabel topLabel = new JLabel("0");
                      
                          public NorthJPanel()
                          {
                              initComposants();
                          }
                      
                          private void initComposants()
                          {
                              topLabel.setPreferredSize(new Dimension(340,35));
                              this.add(topLabel);
                              topLabel.setHorizontalAlignment(JLabel.RIGHT);
                              setBorder(BorderFactory.createLineBorder(Color.BLUE, 5)); 
                          }
                      
                          public JLabel getTopLabel()
                          {
                              return topLabel ;
                          }
                      
                      // Méthode utilitaire de l'affichage.    
                          
                          /** Renvoi ce qui est affiché */
                          public String getAffichage(){
                              return topLabel.getText();
                          }
                          
                          /** Renvoi ce qui est affiché au format numérique */
                          public Double getNumericAffichage(){
                              return Double.parseDouble(topLabel.getText());
                          }
                          
                          /** Affiche le paramètre */
                          public void setAffichage(String str){
                              topLabel.setText(str);
                          }
                          /** Affiche le paramètre */
                          public void setAffichage(int num){
                              topLabel.setText(Integer.toString(num));
                          }
                          
                          /** Efface l'affichage */
                          public void clearAffichage(){
                              topLabel.setText("0");
                          }
                          
                          /** Ajoute à la fin de l'affichage */
                          public void appendAffichage(String str){
                              topLabel.setText(topLabel.getText()+str);
                          }
                          /** Ajoute à la fin de l'affichage */
                          public void appendAffichage(int num){
                              topLabel.setText(topLabel.getText()+num);
                          }
                          
                          /** Vérifie si l'affichage est à 0 */
                          public boolean isClear(){
                              return topLabel.getText().equals("0");
                          }
                          
                          /** Vérifie si l'affichage est un nombre décimal */
                          public boolean isDecimal(){
                              Pattern p = Pattern.compile(".*\\..*");
                              return p.matcher(topLabel.getText()).matches();
                          }
                          
                      }
                      

                      import java.awt.event.*;
                      import javax.swing.*;
                      import java.awt.*;
                      
                      public class CenterJPanel extends JPanel {
                          
                          String str[] = {"1","2","3","4","5","6","7","8","9",".","0","bs"};
                          JButton numbers[] = new JButton[str.length];
                          private boolean update = false;
                          
                          /** Notre écran 
                           * @see NorthJPanel*/
                          private NorthJPanel screen;
                      
                          public CenterJPanel(){
                              initComposants();
                          }
                      
                          public CenterJPanel(NorthJPanel screen){
                              initComposants();
                              this.screen = screen;
                          }
                      
                          private void initComposants(){
                      
                              setLayout(new GridLayout (4, 3, 5, 5));
                              setBackground(Color.CYAN);
                              setBorder(BorderFactory.createLineBorder(Color.BLUE, 5)); 
                      
                              for (int i = 0 ; i < str.length ; i++){
                                  numbers[i] = new JButton(str[i]);
                                  numbers[i].setPreferredSize(new Dimension(65,35)); 
                                  this.add(numbers[i]);
                                  if(i == 9) numbers[i].addActionListener(new DecimalListener());
                                  else if(i == 11) numbers[i].addActionListener(new BSListener());
                                  else numbers[i].addActionListener(new NumberListener());
                              }
                          }
                      
                          class NumberListener implements ActionListener{
                              
                              public void actionPerformed (ActionEvent e){
                                  JButton source = (JButton)e.getSource();
                                  int number = Integer.parseInt(source.getText());
                                  switch(number){
                                      case 0:
                                          if(!screen.isClear()) screen.appendAffichage(0);
                                          break;
                                      default:
                                          if(screen.isClear()) screen.setAffichage(number);
                                          else screen.appendAffichage(number);
                                          break;
                                  }
                              }
                          } 
                      
                          class DecimalListener implements ActionListener{
                              public void actionPerformed(ActionEvent e)
                              {
                                  if(!screen.isDecimal()){
                                      screen.appendAffichage(".");
                                  }
                              }
                          }
                      
                          class BSListener implements ActionListener{
                              
                              public void actionPerformed(ActionEvent e)
                              {
                                  screen.clearAffichage();
                              }
                          }
                      
                      }
                      
                      • Partager sur Facebook
                      • Partager sur Twitter

                      la Calculatrice

                      × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                      × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
                      • Editeur
                      • Markdown