devbox
羊村懒王
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

GUI：简易计算器设计_使用gui,创建一个计算器,并完成基本的四则运算功能

作者：羊村懒王 | 2024-03-20 18:20:49

赞

踩

使用gui,创建一个计算器,并完成基本的四则运算功能

目录

一.界面设计

二.功能设计

 三.代码实现

 四.注意事项

一.界面设计

设计计算器界面时，首先需要建立一个Frame容器，作为显示窗口，之后的界面设计即围绕在该显示窗口中添加功能组件来进行后续操作。

在显示窗口上，可将该界面分为两部分，第一部分即为最上方的文本域组件，用于显示要进行计算的式子，所有的计算式与最终结果均在此文本域中显示。第二部分即为下方的按钮组件，在实现下方的按钮组件，设计思路为，新建若干个Panel容器，将其设置为FlowLayout分布式，以行为单位添加每一行的按钮组件，最后采用Box容器，向其添加之前新建的Panel容器，由于Frame容器默认为BorderLayout分布方式，将文本域组件放置于NORTH，将按钮组件放置于CENTER，之后调整Frame容器的可见性以及大小参数，此时即完成了计算器的界面设计，得到效果图如下：

二.功能设计

在计算器的功能设计中，分为输入过程功能设计与计算过程功能设计。

第一步，输入过程功能设计。该过程主要实现在点击按钮后，在文本域组件中显示点击的按钮内容，以此构成要计算的算式。在这过程中要注意，不能连续出现两个运算符，否则为错误的算式。

此过程采用的实现方式为采用自定义事件监听器的方式，分别对数字按钮和运算符按钮设计自定义事件监听器。

  1. //定义数字按钮的事件监听器类
  2. class myListener_01 implements ActionListener
  3.         {
  4.             @Override
  5.             public void actionPerformed(ActionEvent e) {
  6.                 ta.append(e.getActionCommand());
  7.             }
  8.         }
  1. //定义运算符的事件监听器类
  2. /*
  3.     1.不能多个运算符相连，否则则不显示后添加的运算符
  4.     2.除号后不能只写0，若除号后只写0，再输入运算符时，会将0删除
  5. */
  6. class myListener_02 implements ActionListener
  7.         {
  8.             @Override
  9.             public void actionPerformed(ActionEvent e) {
  10.                 String str = ta.getText();
  11.                 String chs = String.valueOf(str.charAt(str.length() - 1));
  12.                 String ch = String.valueOf(str.charAt(str.length()-2));
  13.                 if(chs.equals("/") || chs.equals("-") || chs.equals("*") || chs.equals("+"));
  14.                 else if(chs.equals("0") && ch.equals("/"))
  15.                 {
  16.                     StringBuilder sb = new StringBuilder(str);
  17.                     sb.delete(str.length()-1,str.length());
  18.                     ta.setText(sb.toString());
  19.                 }
  20.                 else{
  21.                     ta.append(e.getActionCommand());
  22.                 }
  23.             }
  24.         }

第二步，计算过程功能设计。通过输入过程的功能设计可以保证输入的算式符合运算规则，在计算过程功能设计中，主要针对在用户点击“=”后按照运算规则进行计算，得出正确结果。

在此过程中采用的方法为，首先取到文本域中此时的算式内容，由于此内容为String类型无法进行直接运算，所以应将其中的数字和算术符进行分离，转化为正确的格式，此处采取遍历的方式进行初步筛选，以此就实现了文本域组件中的内容提取。

  1. /*
  2.     此方法需要传入取得的文本域内容，一个用于存储数字的数组，一个用于存储运算符的数组
  3. */
  4. public void Traverse(String str,ArrayList<Double> arr,ArrayList<String> chs)
  5.     {
  6.         StringBuilder sb = new StringBuilder();
  7.         for(int i=0;i<str.length();++i)
  8.         {
  9.             String ch = String.valueOf(str.charAt(i));
  10.             if(ch.equals("/") || ch.equals("*") || ch.equals("+") || ch.equals("-") || ch.equals("="))
  11.             {
  12.                 arr.add(Double.valueOf(sb.toString()));
  13.                 chs.add(ch);
  14.                 sb.setLength(0);
  15.                 continue;
  16.             }
  17.             else
  18.             {
  19.                 sb.append(ch);
  20.             }
  21.         }
  22.     }

 之后按照运算规则，为“=”号添加事件监听器，按照上文进行内容提取后，建立运算符在数组中对应的下标与其左右的数字在数组中下标的对应关系，按照先乘除，后加减的顺序进行计算，最终得出运算结果，并显示在文本域中，以此完成此次运算。

  1. b44.addActionListener(new ActionListener() {
  2.             @Override
  3.             public void actionPerformed(ActionEvent e) {
  4.                 ta.append(e.getActionCommand());
  5.                 ArrayList<Double> arr = new ArrayList<Double>();
  6.                 ArrayList<String> chs = new ArrayList<String>();
  7.                 Traverse(ta.getText(),arr,chs);
  8.  
  9.                 Double[] d = new Double[arr.size()];
  10.                 String[] s = new String[chs.size()];
  11. //                System.out.println(arr);
  12. //                System.out.println(chs);
  13.                 boolean flag = true;
  14.                 for(int i=0;i<arr.size();++i)
  15.                 {
  16.                     d[i] = arr.get(i);
  17.                 }
  18.                 for(int i=0;i<chs.size();++i)
  19.                 {
  20.                     s[i] = chs.get(i);
  21.                 }
  22.  
  23.                 for(int i=0;i < s.length;++i)
  24.                 {
  25.                     if(s[i].equals("*"))
  26.                     {
  27.                         d[i] = d[i] * d[i+1];
  28.                         sort(d,i+1);
  29.                         sort(s,i);
  30.                     }
  31.  
  32.                     if(s[i].equals("/") && d[i+1] != 0)
  33.                     {
  34.                         d[i] = d[i] / d[i+1];
  35.                         sort(d,i+1);
  36.                         sort(s,i);
  37.                     }
  38.                     else if (s[i].equals("/") && d[i+1] == 0)
  39.                     {
  40.                         ta.setText("非法输入");
  41.                         flag = false;
  42.                     }
  43.                 }
  44.  
  45.                 for(int i=0;i < s.length;++i)
  46.                 {
  47.                     if(s[i].equals("+"))
  48.                     {
  49.                         d[i] = d[i] + d[i+1];
  50.                         sort(d,i+1);
  51.                         sort(s,i);
  52.                     }
  53.                     if(s[i].equals("-"))
  54.                     {
  55.                         d[i] = d[i] - d[i+1];
  56.                         sort(d,i+1);
  57.                         sort(s,i);
  58.                     }
  59.                 }
  60.                 if(flag) {
  61.                     BigDecimal bd = new BigDecimal(d[0]);
  62.                     bd = bd.setScale(2, RoundingMode.HALF_UP);
  63.                     ta.append(bd.toString());
  64.                 }
  65.             }
  66.         });

 三.代码实现

  1. import javax.swing.*;
  2. import java.awt.*;
  3. import java.awt.event.ActionEvent;
  4. import java.awt.event.ActionListener;
  5. import java.awt.event.WindowAdapter;
  6. import java.awt.event.WindowEvent;
  7. import java.math.BigDecimal;
  8. import java.math.RoundingMode;
  9. import java.util.ArrayList;
  10.  
  11. public class Counter {
  12.     //定义一个Window窗口
  13.     Frame frame = new Frame("计算器");
  14.  
  15.     //组装界面
  16.     public void Init()
  17.     {
  18.         //创建计算器的按键
  19.         Panel p1 = new Panel(new FlowLayout(FlowLayout.LEFT,40,10));
  20.         Button b11 = new Button("C");
  21.         Button b12 = new Button("/");
  22.         Button b13 = new Button("*");
  23.         Button b14 = new Button("del");
  24.         p1.add(b11);
  25.         p1.add(b12);
  26.         p1.add(b13);
  27.         p1.add(b14);
  28.  
  29.         Panel p2 = new Panel(new FlowLayout(FlowLayout.LEFT,40,10));
  30.         Button b21 = new Button("7");
  31.         Button b22 = new Button("8");
  32.         Button b23 = new Button("9");
  33.         Button b24 = new Button("-");
  34.         p2.add(b21);
  35.         p2.add(b22);
  36.         p2.add(b23);
  37.         p2.add(b24);
  38.  
  39.         Panel p3 = new Panel(new FlowLayout(FlowLayout.LEFT,40,10));
  40.         Button b31 = new Button("4");
  41.         Button b32 = new Button("5");
  42.         Button b33 = new Button("6");
  43.         Button b34 = new Button("+");
  44.         p3.add(b31);
  45.         p3.add(b32);
  46.         p3.add(b33);
  47.         p3.add(b34);
  48.  
  49.         Panel p4 = new Panel(new FlowLayout(FlowLayout.LEFT,40,10));
  50.         Button b41 = new Button("1");
  51.         Button b42 = new Button("2");
  52.         Button b43 = new Button("3");
  53.         p4.add(b41);
  54.         p4.add(b42);
  55.         p4.add(b43);
  56.  
  57.         Panel p5 = new Panel(new FlowLayout(FlowLayout.LEFT,40,10));
  58.         Button b51 = new Button("%");
  59.         Button b52 = new Button("0");
  60.         Button b53 = new Button(".");
  61.         p5.add(b51);
  62.         p5.add(b52);
  63.         p5.add(b53);
  64.  
  65.         //组装按键
  66.         Box vbox1 = Box.createVerticalBox();
  67.         vbox1.add(p4);
  68.         vbox1.add(p5);
  69.         Box hbox1 = Box.createHorizontalBox();
  70.         Button b44 = new Button("=");
  71.         b44.setSize(25,128);
  72.         hbox1.add(vbox1);
  73.         hbox1.add(b44);
  74.         hbox1.add(Box.createHorizontalStrut(45));
  75.  
  76.  
  77.         Box vbox2 = Box.createVerticalBox();
  78.         vbox2.add(p1);
  79.         vbox2.add(p2);
  80.         vbox2.add(p3);
  81.         vbox2.add(hbox1);
  82.  
  83.         //组装计算器界面
  84.         Panel panel = new Panel(new BorderLayout());
  85.         TextArea ta = new TextArea(5,10);
  86.         panel.add(ta,BorderLayout.NORTH);
  87.         panel.add(vbox2);
  88.         panel.setSize(421,521);
  89.  
  90.         frame.add(panel);
  91.         frame.pack();
  92.         frame.setLocation(200,200);
  93.         frame.setResizable(false);
  94.         frame.setVisible(true);
  95.  
  96.         //添加事件监听器
  97.         frame.addWindowListener(new WindowAdapter() {
  98.             @Override
  99.             public void windowClosing(WindowEvent e) {
  100.                 System.exit(0);
  101.             }
  102.         });
  103.  
  104.         b11.addActionListener(new ActionListener() {
  105.             @Override
  106.             public void actionPerformed(ActionEvent e) {
  107.                 ta.setText("");
  108.             }
  109.         });
  110.  
  111.         class myListener_01 implements ActionListener
  112.         {
  113.             @Override
  114.             public void actionPerformed(ActionEvent e) {
  115.                 ta.append(e.getActionCommand());
  116.             }
  117.         }
  118.  
  119.         myListener_01 myListener_01 = new myListener_01();
  120.         b21.addActionListener(myListener_01);
  121.         b22.addActionListener(myListener_01);
  122.         b23.addActionListener(myListener_01);
  123.         b31.addActionListener(myListener_01);
  124.         b32.addActionListener(myListener_01);
  125.         b33.addActionListener(myListener_01);
  126.         b41.addActionListener(myListener_01);
  127.         b42.addActionListener(myListener_01);
  128.         b43.addActionListener(myListener_01);
  129.         b52.addActionListener(myListener_01);
  130.         b53.addActionListener(myListener_01);
  131.  
  132.         b14.addActionListener(new ActionListener() {
  133.             @Override
  134.             public void actionPerformed(ActionEvent e) {
  135.                 StringBuilder sb = new StringBuilder(ta.getText());
  136.                 sb.delete(sb.length()-1,sb.length());
  137.                 ta.setText(sb.toString());
  138.             }
  139.         });
  140.  
  141.         class myListener_02 implements ActionListener
  142.         {
  143.             @Override
  144.             public void actionPerformed(ActionEvent e) {
  145.                 String str = ta.getText();
  146.                 String chs = String.valueOf(str.charAt(str.length() - 1));
  147.                 String ch = String.valueOf(str.charAt(str.length()-2));
  148.                 if(chs.equals("/") || chs.equals("-") || chs.equals("*") || chs.equals("+"));
  149.                 else if(chs.equals("0") && ch.equals("/"))
  150.                 {
  151.                     StringBuilder sb = new StringBuilder(str);
  152.                     sb.delete(str.length()-1,str.length());
  153.                     ta.setText(sb.toString());
  154.                 }
  155.                 else{
  156.                     ta.append(e.getActionCommand());
  157.                 }
  158.             }
  159.         }
  160.  
  161.         myListener_02 myListener_02 = new myListener_02();
  162.         b12.addActionListener(myListener_02);
  163.         b13.addActionListener(myListener_02);
  164.         b24.addActionListener(myListener_02);
  165.         b34.addActionListener(myListener_02);
  166.  
  167.         b44.addActionListener(new ActionListener() {
  168.             @Override
  169.             public void actionPerformed(ActionEvent e) {
  170.                 ta.append(e.getActionCommand());
  171.                 ArrayList<Double> arr = new ArrayList<Double>();
  172.                 ArrayList<String> chs = new ArrayList<String>();
  173.                 Traverse(ta.getText(),arr,chs);
  174.  
  175.                 Double[] d = new Double[arr.size()];
  176.                 String[] s = new String[chs.size()];
  177. //                System.out.println(arr);
  178. //                System.out.println(chs);
  179.                 boolean flag = true;
  180.                 for(int i=0;i<arr.size();++i)
  181.                 {
  182.                     d[i] = arr.get(i);
  183.                 }
  184.                 for(int i=0;i<chs.size();++i)
  185.                 {
  186.                     s[i] = chs.get(i);
  187.                 }
  188.  
  189.                 for(int i=0;i < s.length;++i)
  190.                 {
  191.                     if(s[i].equals("*"))
  192.                     {
  193.                         d[i] = d[i] * d[i+1];
  194.                         sort(d,i+1);
  195.                         sort(s,i);
  196.                     }
  197.  
  198.                     if(s[i].equals("/") && d[i+1] != 0)
  199.                     {
  200.                         d[i] = d[i] / d[i+1];
  201.                         sort(d,i+1);
  202.                         sort(s,i);
  203.                     }
  204.                     else if (s[i].equals("/") && d[i+1] == 0)
  205.                     {
  206.                         ta.setText("非法输入");
  207.                         flag = false;
  208.                     }
  209.                 }
  210.  
  211.                 for(int i=0;i < s.length;++i)
  212.                 {
  213.                     if(s[i].equals("+"))
  214.                     {
  215.                         d[i] = d[i] + d[i+1];
  216.                         sort(d,i+1);
  217.                         sort(s,i);
  218.                     }
  219.                     if(s[i].equals("-"))
  220.                     {
  221.                         d[i] = d[i] - d[i+1];
  222.                         sort(d,i+1);
  223.                         sort(s,i);
  224.                     }
  225.                 }
  226.                 if(flag) {
  227.                     BigDecimal bd = new BigDecimal(d[0]);
  228.                     bd = bd.setScale(2, RoundingMode.HALF_UP);
  229.                     ta.append(bd.toString());
  230.                 }
  231.             }
  232.         });
  233.  
  234.     }
  235.  
  236.     public  void sort(Object[] arr,int pos)
  237.     {
  238.         for(int j=pos;j<arr.length-1;++j)
  239.         {
  240.             arr[j] = arr[j+1];
  241.         }
  242.     }
  243.  
  244.     public void Traverse(String str,ArrayList<Double> arr,ArrayList<String> chs)
  245.     {
  246.         StringBuilder sb = new StringBuilder();
  247.         for(int i=0;i<str.length();++i)
  248.         {
  249.             String ch = String.valueOf(str.charAt(i));
  250.             if(ch.equals("/") || ch.equals("*") || ch.equals("+") || ch.equals("-") || ch.equals("="))
  251.             {
  252.                 arr.add(Double.valueOf(sb.toString()));
  253.                 chs.add(ch);
  254.                 sb.setLength(0);
  255.                 continue;
  256.             }
  257.             else
  258.             {
  259.                 sb.append(ch);
  260.             }
  261.         }
  262.     }
  263.  
  264.     public static void main(String[] args) {
  265.         new Counter().Init();
  266.     }
  267. }

 四.注意事项

由于编译器译码方式的不同，再不加修改的情况下运行上述代码，最后的界面中按钮部分内容无法正常显示，若想正常显示内容，可按照下图修改：（采用IDEA演示）

 

在完成上述修改后，再运行程序，即可正常显示。

 可能存在思虑不周的情况，若有更好的实现方式，欢迎斧正！

共同进步！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/275655
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号