（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
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)
