JAVA-实用计算器的设计与实现（实现算数优先级）

（1）本程序实现了一个实用的计算器程序，具体功能实现如下：

A. 实现实用计算器的简易界面。

B. 实现按钮的监听。

C．至少有加、减、乘、除、清除5种运算。

D．可以连续运算，并能按照优先级运算。

---

（2）本程序为练习程序，基本要求如下：

1. 深入学习并掌握Java的基本语法；

2. 掌握Java运算符的使用方法及优先级；

3. 掌握Java按钮监听的方法；

4. 掌握Java Swing的GUI图形用户界面编程设计；

5. 熟练掌握Java软件开发的基本过程。

---

（3）程序源码：

1.界面设计部分：（可以参照我的《JAVA-关于计算器的简单图形界面设计例子（不实现功能）》这篇内容）

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.text.SimpleDateFormat;
import java.util.Date;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextArea;
import javax.swing.Timer;
import javax.swing.WindowConstants;


public class TingerCalc extends JFrame {
	// 结果重置标致
	private boolean resultFlag = false;
	//显示文本
	private String displayText= "当前时间";
	// 创建文本域，放置输入数据和结果
	JTextArea JText = new JTextArea();
	// 创建文本域，放置输入数据和结果
	JTextArea JTextResult = new JTextArea();
	public TingerCalc() {
		// 创建窗口
		final JFrame JWindow = new JFrame("计算器");
		// 设置为流动布局，居中
		JWindow.setLayout(new FlowLayout(1,6,6)); 
		// 设置窗体尺寸为宽350 高 320
		JWindow.setSize(350,360);
		// 设置窗口相对于指定组件的位置。如果组件当前未显示或者 null，则此窗口将置于屏幕的中央。
		JWindow.setLocationRelativeTo(null);
 		//用户单击窗口的关闭按钮时程序执行的操作 WindowConstants.EXIT_ON_CLOSE 代表关闭退出
		JWindow.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		// 不可以改变大小
		JWindow.setResizable(false); 
		// 设置字体
		Font font = new Font("宋体", Font.PLAIN, 20);

		// 创建容器,存放显示算式框和结果框，采用流式布局 居中显示 水平间距为12 水平间距为0
		JPanel Panel = new JPanel(new FlowLayout(FlowLayout.CENTER, 12, 0));
		
		//将文本框 设置字体
		JText.setFont(font);
		// 设置大小
		JText.setPreferredSize(new Dimension(200,30));
		// 设置不可编辑
//		JText.setEditable(false);
		JText.addKeyListener(new MyKeyListener());
		// 添加到容器中
		Panel.add(JText);
		//将文本框 设置字体
		JTextResult.setFont(font);
		// 设置大小
		JTextResult.setPreferredSize(new Dimension(90,30));
		// 设置不可编辑
		JTextResult.setEditable(false);
		// 添加到容器中
		Panel.add(JTextResult);
		
		// 定义按钮面板，并设置为网格布局，5行4列，组件水平为8、垂直间距均为12
		JPanel Panel2 = new JPanel(new GridLayout(5,4,8,12));
		
		// 按钮数组
		String BtnStr[] = { "1","2","3","+",
							"4","5","6","-",
							"7","8","9","*",
							".","0","C","/",
							"(",")"};
		JButton Btn[] = new JButton[BtnStr.length];
		for(int i = 0 ; i < BtnStr.length ; i++ ){
		    Btn[i]=new JButton(BtnStr[i]);
		    Btn[i].setFont(font);
		    // 设置按钮尺寸为70*72
		    Dimension dimension = new Dimension(70,42);
		    Btn[i].setPreferredSize(dimension);
		    String BtnStrText = BtnStr[i];
		    Btn[i].addActionListener(new ActionListener() {
				@Override
				public void actionPerformed(ActionEvent e) {
					//判断按钮是不是C（清除按钮）并且false是否为FALSE 是的话就清除JText，
					//不是的话就对JText获取原来的内容后连接新内容输入到JText内
					if(BtnStrText!="C") {
						// 连续运算标志判断
						if (!resultFlag) {
							JText.setText(JText.getText()+BtnStrText);
						}else {
							JText.setText(BtnStrText);
						}
					}else {
						JText.setText("");
						JTextResult.setText("");
					}
					resultFlag=false;
				}
			});
		    Panel2.add(Btn[i]);
		}
		//	创建等号按钮 设置监听
		JButton EqualSign=new JButton("=");
		EqualSign.setFont(font);
		// 创建一个算式计算对象，用于传计算等式，获取结果 
		ArithmeticOperation result = new ArithmeticOperation(3);
		EqualSign.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				//判断按钮是不是C（清楚按钮）是的话就清除JText，不是的话就对JText获取原来的内容后连接新内容输入到JText种
				JTextResult.setText(result.caculate(JText.getText()));
				resultFlag = true;
			}
		});
	    // 设置按钮尺寸为70*72
	    EqualSign.setPreferredSize(new Dimension(70,42));
	    Panel2.add(EqualSign);
	    
	    JLabel lab = new JLabel(displayText,JLabel.CENTER) ;
	    Panel2.add(lab);
	    this.setTimer(lab);
	   
		// 把 面板容器 设置到 窗口
			// Panel 设置到顶部
		JWindow.getContentPane().add(Panel,BorderLayout.NORTH);
			// Panel 设置到底部
		JWindow.getContentPane().add(Panel2,BorderLayout.CENTER);
		// 显示窗口，前面创建的信息都在内存中，通过 JWindow.setVisible(true) 把内存中的窗口显示在屏幕上。
		JWindow.setVisible(true);
	}
	// 键盘监听案件
	class MyKeyListener implements KeyListener {
        @Override // 输入的内容
        public void keyTyped(KeyEvent e) {
        	// 监听退格键，按退格清楚文本
        	if(e.getKeyChar()!=KeyEvent.VK_BACK_SPACE) {
				// 连续运算标志判断
				if (resultFlag) {
					JText.setText(""+e.getKeyChar());
				}
			}else {
				JText.setText("");
				JTextResult.setText("");
			}
			resultFlag=false;
        }

		@Override
		public void keyPressed(KeyEvent e) {}

		@Override
		public void keyReleased(KeyEvent e) {}
	}
	// 1000ms实现一次动作
	private void setTimer(JLabel time) {
		final JLabel varTime = time;
		Timer timeAction = new Timer(1000, new ActionListener() {
			long timemillis2 = (System.currentTimeMillis()-1000);
			public void actionPerformed(ActionEvent e) {
				long timemillis1 = System.currentTimeMillis();
				long timemillis = timemillis1;//-timemillis2;
						// 转换日期显示格式
				SimpleDateFormat df = new SimpleDateFormat("HH:mm:ss");
				varTime.setText("<html><body><font color=#0099FF>"+displayText+"<br/>"+df.format(new Date(timemillis))+"</font></body></html>");
			}
		});
		timeAction.start();
	} // 运行方法

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		TingerCalc tingerCalc = new TingerCalc();
	}

}

我在计算器界面中添加了一个实时小时钟模块~

2.运算部分：

1. 实现了带括号的优先级运算（堆栈方式）；

2. 解决了除法遇到0结果时的可能出错问题（引入浮点计算，利用无穷）；

3. 实现了连续运算；

import java.math.BigDecimal;
import java.util.Stack;


public class ArithmeticOperation {
	private int accuracy; // 进行除法出现无线循环小数时保留的精度
    // 数字栈：用于存储表达式中的各个数字
    private Stack<String> DigitalStack = null;
    // 符号栈：用于存储运算符和括号
    private Stack<Character> SymbolStack = null;
 
    public ArithmeticOperation(int accuracy) {
        super();
        this.accuracy = accuracy;
    }    
    // 解析并计算四则运算表达式(含括号优先级)，返回计算结果
    public String caculate(String numStr) {
        // 在尾部添加'='，表示结束符
        numStr += "=";
        // 检查表达式是否合法
        if (!isStandard(numStr)) {
            return "算式错误";
        }
        // 初始化栈
        if (DigitalStack == null) {
            DigitalStack = new Stack<String>();
        }
        DigitalStack.clear();
        if (SymbolStack == null) {
            SymbolStack = new Stack<Character>();
        }
        SymbolStack.clear();
        // 用于缓存数字，因为数字可能是多位的
        StringBuffer temp = new StringBuffer();
        // 从表达式的第一个字符开始处理
        for (int i = 0; i < numStr.length(); i++) {
            char ch = numStr.charAt(i); // 获取一个字符
            if (isNumber(ch)) { // 若当前字符是数字
                temp.append(ch); // 加入到数字缓存中
            } else { // 非数字的情况
                String tempStr = temp.toString(); // 将数字缓存转为字符串
                if (!tempStr.isEmpty()) {
                	String num = new String(tempStr);
                    DigitalStack.push(num); // 将数字压栈
                    temp = new StringBuffer(); // 重置数字缓存
                }
                // 判断运算符的优先级，若当前优先级低于栈顶的优先级，则先把计算前面计算出来
                while (!ComparePriority(ch) && !SymbolStack.empty()) {
                	double b = Double.parseDouble(DigitalStack.pop()); // 出栈，取出数字，后进先出
                	double a = Double.parseDouble(DigitalStack.pop());
                    // 取出运算符进行相应运算，并把结果压栈进行下一次运算
                    switch ((char) SymbolStack.pop()) {
                    case '+':
                    	DigitalStack.push(String.valueOf(a+b));
                        break;
                    case '-':
                    	DigitalStack.push(String.valueOf(a-b));
                        break;
                    case '*':
                    	DigitalStack.push(String.valueOf(a*b));
                        break;
                    case '/':
                        try {
                        	if(b!=0) {
                        		DigitalStack.push(String.valueOf(a/b));
                        	}else {
                        		return "∞";
                        	}
                        } catch (java.lang.ArithmeticException e) {
                            // 进行除法出现无限循环小数时，就会抛异常，此处设置精度重新计算
                        	DigitalStack.push(new BigDecimal(a/b).setScale(this.accuracy,BigDecimal.ROUND_HALF_UP).toString()); 
                        }
                        break;
                    default:
                        break;
                    }
                } 
                if (ch != '=') {
                    SymbolStack.push(new Character(ch)); // 符号入栈
                    if (ch == ')') { // 去括号
                        SymbolStack.pop();
                        SymbolStack.pop();
                    }
                }
            }
        } // for循环结束
        
        return DigitalStack.pop(); // 返回计算结果
    }
    //检查算术表达式的基本合法性，符合返回true，否则false
    private boolean isStandard(String numStr) {
        if (numStr == null || numStr.isEmpty()) // 表达式不能为空
            return false;
        Stack<Character> stack = new Stack<Character>(); // 用来保存括号，检查左右括号是否匹配
        for (int i = 0; i < numStr.length(); i++) {
            char n = numStr.charAt(i);
            // 判断字符是否合法
            if (!(isNumber(n) || "(".equals(n + "") || ")".equals(n + "")
                    || "+".equals(n + "") || "-".equals(n + "")
                    || "*".equals(n + "") || "/".equals(n + "") || "=".equals(n
                    + ""))) {
                return false;
            }
            // 将左括号压栈，用来给后面的右括号进行匹配
            if ("(".equals(n + "")) {
                stack.push(n);
            }
            if (")".equals(n + "")) { // 匹配括号
                if (stack.isEmpty() || !"(".equals((char) stack.pop() + "")) // 括号是否匹配
                    return false;
            }
        }
        // 可能会有缺少右括号的情况
        if (!stack.isEmpty())
            return false;
        return true;
    }
 
    private boolean isNumber(char num) {
        if ((num >= '0' && num <= '9') || num == '.')
            return true;
        return false;
    }
 
    // 如果当前运算符比栈顶元素运算符优先级高则返回true，否则返回false
    // 符号优先级定义按顺序: (   大于   * /   大于   + -  大于   )

    private boolean ComparePriority(char symbol) {
        if (SymbolStack.empty()) { // 栈空为 true
            return true;
        }
 
        char StackTop = (char) SymbolStack.peek(); // 查看堆栈顶部的内容
        if (StackTop == '(') {
            return true;
        }
        // 比较优先级
        switch (symbol) {
        case '(': // 优先级最高
            return true;
        case '*': {
            if (StackTop == '+' || StackTop == '-')
                return true;
            else
                return false;
        }
        case '/': {
            if (StackTop == '+' || StackTop == '-')
                return true;
            else
                return false;
        }
        case '+':
            return false;
        case '-':
            return false;
        case ')': // 优先级最低
            return false;
        case '=': // 结束符
            return false;
        default:
            break;
        }
        return true;
    }
}

本程序为我的Java课程设计内容，如果需要观看我的课程设计报告，可以移步我的资源区~

菜鸡勿喷QAQ