Pastebin.vip

Java calculator (imitating the functions and interfaces of windows built-in calculator)

From , 3 Years ago, written in Java, viewed 162 times.
URL https://pastebin.vip/view/26dd0dbc
  1. import java.awt.BorderLayout;
  2. import java.awt.Color;
  3. import java.awt.GridLayout;
  4. import java.awt.event.ActionEvent;
  5. import java.awt.event.ActionListener;
  6.  
  7. import javax.swing.JButton;
  8. import javax.swing.JFrame;
  9. import javax.swing.JPanel;
  10. import javax.swing.JTextField;
  11.  
  12. /**
  13.  * 一个计算器，与Windows附件自带计算器的标准版功能、界面相仿。 但还不支持键盘操作。
  14.  */
  15. public class Calculator extends JFrame implements ActionListener {
  16.         /** 计算器上的键的显示名字 */
  17.         private final String[] KEYS = { "7", "8", "9", "/", "sqrt", "4", "5", "6",
  18.                         "*", "%", "1", "2", "3", "-", "1/x", "0", "+/-", ".", "+", "=" };
  19.         /** 计算器上的功能键的显示名字 */
  20.         private final String[] COMMAND = { "Backspace", "CE", "C" };
  21.         /** 计算器左边的M的显示名字 */
  22.         private final String[] M = { " ", "MC", "MR", "MS", "M+" };
  23.         /** 计算器上键的按钮 */
  24.         private JButton keys[] = new JButton[KEYS.length];
  25.         /** 计算器上的功能键的按钮 */
  26.         private JButton commands[] = new JButton[COMMAND.length];
  27.         /** 计算器左边的M的按钮 */
  28.         private JButton m[] = new JButton[M.length];
  29.         /** 计算结果文本框 */
  30.         private JTextField resultText = new JTextField("0");
  31.  
  32.         // 标志用户按的是否是整个表达式的第一个数字,或者是运算符后的第一个数字
  33.         private boolean firstDigit = true;
  34.         // 计算的中间结果。
  35.         private double resultNum = 0.0;
  36.         // 当前运算的运算符
  37.         private String operator = "=";
  38.         // 操作是否合法
  39.         private boolean operateValidFlag = true;
  40.  
  41.         /**
  42.          * 构造函数
  43.          */
  44.         public Calculator() {
  45.                 super();
  46.                 // 初始化计算器
  47.                 init();
  48.                 // 设置计算器的背景颜色
  49.                 this.setBackground(Color.LIGHT_GRAY);
  50.                 this.setTitle("计算器");
  51.                 // 在屏幕(500, 300)坐标处显示计算器
  52.                 this.setLocation(500, 300);
  53.                 // 不许修改计算器的大小
  54.                 this.setResizable(false);
  55.                 // 使计算器中各组件大小合适
  56.                 this.pack();
  57.         }
  58.  
  59.         /**
  60.          * 初始化计算器
  61.          */
  62.         private void init() {
  63.                 // 文本框中的内容采用右对齐方式
  64.                 resultText.setHorizontalAlignment(JTextField.RIGHT);
  65.                 // 不允许修改结果文本框
  66.                 resultText.setEditable(false);
  67.                 // 设置文本框背景颜色为白色
  68.                 resultText.setBackground(Color.WHITE);
  69.  
  70.                 // 初始化计算器上键的按钮，将键放在一个画板内
  71.                 JPanel calckeysPanel = new JPanel();
  72.                 // 用网格布局器，4行，5列的网格，网格之间的水平方向间隔为3个象素，垂直方向间隔为3个象素
  73.                 calckeysPanel.setLayout(new GridLayout(4, 5, 3, 3));
  74.                 for (int i = 0; i < KEYS.length; i++) {
  75.                         keys[i] = new JButton(KEYS[i]);
  76.                         calckeysPanel.add(keys[i]);
  77.                         keys[i].setForeground(Color.blue);
  78.                 }
  79.                 // 运算符键用红色标示，其他键用蓝色表示
  80.                 keys[3].setForeground(Color.red);
  81.                 keys[8].setForeground(Color.red);
  82.                 keys[13].setForeground(Color.red);
  83.                 keys[18].setForeground(Color.red);
  84.                 keys[19].setForeground(Color.red);
  85.  
  86.                 // 初始化功能键，都用红色标示。将功能键放在一个画板内
  87.                 JPanel commandsPanel = new JPanel();
  88.                 // 用网格布局器，1行，3列的网格，网格之间的水平方向间隔为3个象素，垂直方向间隔为3个象素
  89.                 commandsPanel.setLayout(new GridLayout(1, 3, 3, 3));
  90.                 for (int i = 0; i < COMMAND.length; i++) {
  91.                         commands[i] = new JButton(COMMAND[i]);
  92.                         commandsPanel.add(commands[i]);
  93.                         commands[i].setForeground(Color.red);
  94.                 }
  95.  
  96.                 // 初始化M键，用红色标示，将M键放在一个画板内
  97.                 JPanel calmsPanel = new JPanel();
  98.                 // 用网格布局管理器，5行，1列的网格，网格之间的水平方向间隔为3个象素，垂直方向间隔为3个象素
  99.                 calmsPanel.setLayout(new GridLayout(5, 1, 3, 3));
  100.                 for (int i = 0; i < M.length; i++) {
  101.                         m[i] = new JButton(M[i]);
  102.                         calmsPanel.add(m[i]);
  103.                         m[i].setForeground(Color.red);
  104.                 }
  105.  
  106.                 // 下面进行计算器的整体布局，将calckeys和command画板放在计算器的中部，
  107.                 // 将文本框放在北部，将calms画板放在计算器的西部。
  108.  
  109.                 // 新建一个大的画板，将上面建立的command和calckeys画板放在该画板内
  110.                 JPanel panel1 = new JPanel();
  111.                 // 画板采用边界布局管理器，画板里组件之间的水平和垂直方向上间隔都为3象素
  112.                 panel1.setLayout(new BorderLayout(3, 3));
  113.                 panel1.add("North", commandsPanel);
  114.                 panel1.add("Center", calckeysPanel);
  115.  
  116.                 // 建立一个画板放文本框
  117.                 JPanel top = new JPanel();
  118.                 top.setLayout(new BorderLayout());
  119.                 top.add("Center", resultText);
  120.  
  121.                 // 整体布局
  122.                 getContentPane().setLayout(new BorderLayout(3, 5));
  123.                 getContentPane().add("North", top);
  124.                 getContentPane().add("Center", panel1);
  125.                 getContentPane().add("West", calmsPanel);
  126.                 // 为各按钮添加事件侦听器
  127.                 // 都使用同一个事件侦听器，即本对象。本类的声明中有implements ActionListener
  128.                 for (int i = 0; i < KEYS.length; i++) {
  129.                         keys[i].addActionListener(this);
  130.                 }
  131.                 for (int i = 0; i < COMMAND.length; i++) {
  132.                         commands[i].addActionListener(this);
  133.                 }
  134.                 for (int i = 0; i < M.length; i++) {
  135.                         m[i].addActionListener(this);
  136.                 }
  137.         }
  138.  
  139.         /**
  140.          * 处理事件
  141.          */
  142.         public void actionPerformed(ActionEvent e) {
  143.                 // 获取事件源的标签
  144.                 String label = e.getActionCommand();
  145.                 if (label.equals(COMMAND[0])) {
  146.                         // 用户按了"Backspace"键
  147.                         handleBackspace();
  148.                 } else if (label.equals(COMMAND[1])) {
  149.                         // 用户按了"CE"键
  150.                         resultText.setText("0");
  151.                 } else if (label.equals(COMMAND[2])) {
  152.                         // 用户按了"C"键
  153.                         handleC();
  154.                 } else if ("0123456789.".indexOf(label) >= 0) {
  155.                         // 用户按了数字键或者小数点键
  156.                         handleNumber(label);
  157.                         // handlezero(zero);
  158.                 } else {
  159.                         // 用户按了运算符键
  160.                         handleOperator(label);
  161.                 }
  162.         }
  163.  
  164.         /**
  165.          * 处理Backspace键被按下的事件
  166.          */
  167.         private void handleBackspace() {
  168.                 String text = resultText.getText();
  169.                 int i = text.length();
  170.                 if (i > 0) {
  171.                         // 退格，将文本最后一个字符去掉
  172.                         text = text.substring(0, i - 1);
  173.                         if (text.length() == 0) {
  174.                                 // 如果文本没有了内容，则初始化计算器的各种值
  175.                                 resultText.setText("0");
  176.                                 firstDigit = true;
  177.                                 operator = "=";
  178.                         } else {
  179.                                 // 显示新的文本
  180.                                 resultText.setText(text);
  181.                         }
  182.                 }
  183.         }
  184.  
  185.         /**
  186.          * 处理数字键被按下的事件
  187.          *
  188.          * @param key
  189.          */
  190.         private void handleNumber(String key) {
  191.                 if (firstDigit) {
  192.                         // 输入的第一个数字
  193.                         resultText.setText(key);
  194.                 } else if ((key.equals(".")) && (resultText.getText().indexOf(".") < 0)) {
  195.                         // 输入的是小数点，并且之前没有小数点，则将小数点附在结果文本框的后面
  196.                         resultText.setText(resultText.getText() + ".");
  197.                 } else if (!key.equals(".")) {
  198.                         // 如果输入的不是小数点，则将数字附在结果文本框的后面
  199.                         resultText.setText(resultText.getText() + key);
  200.                 }
  201.                 // 以后输入的肯定不是第一个数字了
  202.                 firstDigit = false;
  203.         }
  204.  
  205.         /**
  206.          * 处理C键被按下的事件
  207.          */
  208.         private void handleC() {
  209.                 // 初始化计算器的各种值
  210.                 resultText.setText("0");
  211.                 firstDigit = true;
  212.                 operator = "=";
  213.         }
  214.  
  215.         /**
  216.          * 处理运算符键被按下的事件
  217.          *
  218.          * @param key
  219.          */
  220.         private void handleOperator(String key) {
  221.                 if (operator.equals("/")) {
  222.                         // 除法运算
  223.                         // 如果当前结果文本框中的值等于0
  224.                         if (getNumberFromText() == 0.0) {
  225.                                 // 操作不合法
  226.                                 operateValidFlag = false;
  227.                                 resultText.setText("除数不能为零");
  228.                         } else {
  229.                                 resultNum /= getNumberFromText();
  230.                         }
  231.                 } else if (operator.equals("1/x")) {
  232.                         // 倒数运算
  233.                         if (resultNum == 0.0) {
  234.                                 // 操作不合法
  235.                                 operateValidFlag = false;
  236.                                 resultText.setText("零没有倒数");
  237.                         } else {
  238.                                 resultNum = 1 / resultNum;
  239.                         }
  240.                 } else if (operator.equals("+")) {
  241.                         // 加法运算
  242.                         resultNum += getNumberFromText();
  243.                 } else if (operator.equals("-")) {
  244.                         // 减法运算
  245.                         resultNum -= getNumberFromText();
  246.                 } else if (operator.equals("*")) {
  247.                         // 乘法运算
  248.                         resultNum *= getNumberFromText();
  249.                 } else if (operator.equals("sqrt")) {
  250.                         // 平方根运算
  251.                         resultNum = Math.sqrt(resultNum);
  252.                 } else if (operator.equals("%")) {
  253.                         // 百分号运算，除以100
  254.                         resultNum = resultNum / 100;
  255.                 } else if (operator.equals("+/-")) {
  256.                         // 正数负数运算
  257.                         resultNum = resultNum * (-1);
  258.                 } else if (operator.equals("=")) {
  259.                         // 赋值运算
  260.                         resultNum = getNumberFromText();
  261.                 }
  262.                 if (operateValidFlag) {
  263.                         // 双精度浮点数的运算
  264.                         long t1;
  265.                         double t2;
  266.                         t1 = (long) resultNum;
  267.                         t2 = resultNum - t1;
  268.                         if (t2 == 0) {
  269.                                 resultText.setText(String.valueOf(t1));
  270.                         } else {
  271.                                 resultText.setText(String.valueOf(resultNum));
  272.                         }
  273.                 }
  274.                 // 运算符等于用户按的按钮
  275.                 operator = key;
  276.                 firstDigit = true;
  277.                 operateValidFlag = true;
  278.         }
  279.  
  280.         /**
  281.          * 从结果文本框中获取数字
  282.          *
  283.          * @return
  284.          */
  285.         private double getNumberFromText() {
  286.                 double result = 0;
  287.                 try {
  288.                         result = Double.valueOf(resultText.getText()).doubleValue();
  289.                 } catch (NumberFormatException e) {
  290.                 }
  291.                 return result;
  292.         }
  293.  
  294.         public static void main(String args[]) {
  295.                 Calculator calculator1 = new Calculator();
  296.                 calculator1.setVisible(true);
  297.                 calculator1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  298.         }
  299. }
  300.  

Reply to "Java calculator (imitating the functions and interfaces of windows built-in calculator)"

Here you can reply to the paste above

captcha

https://burned.cc - Burn After Reading Website
Powered by Pastebin.vip paste tool since 2022!