使用Java编写一个简单计算器

程序编写思路:
1.页面布局
这里整体的界面采用边框布局，上方输入框和结果框采用流动布局 ；下方按键部分采用网格状布局。
2.按钮事件监听
为计算器每个按钮设置相应的事件监听，是该程序的核心部分。

①首先为0-9这10个数字键和 . + - * / ( )设置事件监听，当点击到该按键时，输入框中出现相对应的数字或符号

//各按钮的时间处理方法
	public void Text(JButton button){
		button.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent arg0) {
				// TODO Auto-generated method stub
				String str=button.getText();
				//System.out.println(str);
				text.setText(text.getText() + str);
			}
		});
	}


②其次是为MC键设置事件监听，使它完成清空输入框中数据的功能

 clear.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				// TODO Auto-generated method stub
				text.setText("");
				resulttext.setText("");
			}
		});


③为删除符号设置事件监听，使每次点击删除按钮，每次删除一位。

prior.addActionListener(new ActionListener() {
			
			@Override
			public void actionPerformed(ActionEvent e) {
				// TODO Auto-generated method stub
				String a = text.getText();
				String b = a.substring(0, a.length() - 1);
				text.setText(b);
			}
		});


④为等于按钮设置事件监听（这是最关键的一步），使每次点击等于按钮，能正确识别算式的格式并输出正确结果。

equ.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				// TODO Auto-generated method stub
				String string = text.getText().trim();
				int flag = Format_detection.isFormate(string);
				
				if(flag == 0) {
					JOptionPane.showMessageDialog(null, "输入为空，请输入算式","警告",JOptionPane.ERROR_MESSAGE);
				}else if(flag == 1) {
					JOptionPane.showMessageDialog(null, "算式格式错误，请输入正确格式的算式","警告",JOptionPane.ERROR_MESSAGE);
					
				}else {
					getResult result = new getResult(string);
					resulttext.setText(result.result_int+"");
				}
				
				}	
		});


3.输入算式的格式判定
该部分是避免开始盲目运算。在计算之前先判断用户输入的算式是否符合格式，这里只是简单地格式判定，复杂的格式判定并未给出，这里是对输入为空，和输入内容的长度进行判断，当输入长度为奇数时，判定格式正确；若输入长度为偶数时，判定格式错误，并给出用户出错内容的警告。至于更详尽的算式格式判定，并未进行。大家可以根据需要下载源码后自行添加更多详尽的格式判定方法。

//检测算式格式是否正确
	public static int isFormate(String string) {
		if(string.equals("") || string.isEmpty()) {
			flag = 0;
		}else {
			List<String> list = new ArrayList<>();
			/*
			getResult.Infix_expression(string)函数是将算式字符串转换为以
			list集合存储的中缀表达式。为后续增加更详细的格式判定提供便
			利。
			*/
			list = getResult.Infix_expression(string);
			if(list.size()%2 == 0) {
				flag = 1;
			}else {
				flag = 2;
			}
		}
		return flag;
	}


4.计算
①在计算之前，我将中缀表达式转换成了后缀表达式，又根据后缀表达式计算结果

②判定算式中运算数是否含有小数，若含有小数，进行小数计算，计算结果为double类型；若不含小数，则进行整数运算，计算结果为in类t型

③这里我将计算分成了正数计算（运算数中不含小数）和小数计算（运算数中含有小数）。将计算结果以字符串的形式传入结果框中。


程序的用户界面显示：



界面程序源代码:
//package 计算器;
import java.awt.BorderLayout;
import java.awt.Dialog;
import java.awt.FlowLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.regex.Pattern;

import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTextField;

public class calculator extends JFrame{
	JPanel viewPanel,panel;
	JTextField text,resulttext;
	JLabel label;
	//"0--9"JButton
	JButton jb0,jb1,jb2,jb3,jb4,jb5,jb6,jb7,jb8,jb9;
 //"+,-,*,/,."JButton
	JButton add,sub,mul,div,bot,equ,left,right,clear,prior;
	
	public calculator(){
		this.setBounds(300,200,400,300);
		this.setTitle("计算器");
		this.setLayout(new BorderLayout());//设置计算机窗体布局方式
		text =new JTextField(15);
		resulttext = new JTextField(15);
		label = new JLabel();
		label.setText("=");
		viewPanel = new JPanel();
		viewPanel.setLayout(new FlowLayout());
		viewPanel.add(text);
		viewPanel.add(label);
		viewPanel.add(resulttext);
		//新建数字按钮
	    jb0 = new JButton("0");
	    jb1 = new JButton("1");
	    jb2 = new JButton("2");
	    jb3 = new JButton("3");
	    jb4 = new JButton("4");
	    jb5 = new JButton("5");
	    jb6 = new JButton("6");
	    jb7 = new JButton("7");
	    jb8 = new JButton("8");
	    jb9 = new JButton("9");
	    
	    //新建符号按钮
	    add = new JButton("+");
	    sub = new JButton("-");
	    mul = new JButton("*");
	    div = new JButton("/");
	    equ = new JButton("=");
	    bot = new JButton(".");
	    left = new JButton("(");
	    right = new JButton(")");
	    clear = new JButton("MC");
	    prior = new JButton("←");
	    //新建计算器数字及符号所在区域面板
	    panel= new JPanel();
	    panel.setLayout(new GridLayout(5,4));        
     //讲个按钮组建放入面板
	    //第一行
	    panel.add(jb7);
	    panel.add(jb8);
	    panel.add(jb9);
	    panel.add(div);
	    //第二行
	    panel.add(jb4);
	    panel.add(jb5);
	    panel.add(jb6);
	    panel.add(mul);
	    //第三行
	    panel.add(jb1);
	    panel.add(jb2);
	    panel.add(jb3);
	    panel.add(sub);
	    //第四行
	    panel.add(bot);
	    panel.add(jb0);
	    panel.add(equ);
	    panel.add(add);
	    //第五行
	    panel.add(left);
	    panel.add(right);
	    panel.add(clear);
	    panel.add(prior);
	    
		this.add(viewPanel,BorderLayout.NORTH);
	    this.add(panel);
	    
	    MyEvent();//事件处理
	    this.setVisible(true);
	    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设置面板可关闭
	}
	public void MyEvent(){
	    //给各数字键添加点击事件
	    Text(jb0);
	    Text(jb1);
	    Text(jb2);
	    Text(jb3);
	    Text(jb4);
	    Text(jb5);
	    Text(jb6);
	    Text(jb7);
	    Text(jb8);
	    Text(jb9);
	    Text(add);
	    Text(sub);
	    Text(mul);
	    Text(div);
	    Text(bot);
	    Text(left);
	    Text(right);
	    clear.addActionListener(new ActionListener() {
			
			@Override
			public void actionPerformed(ActionEvent e) {
				// TODO Auto-generated method stub
				text.setText("");
				resulttext.setText("");
			}
		});
	    prior.addActionListener(new ActionListener() {
			
			@Override
			public void actionPerformed(ActionEvent e) {
				// TODO Auto-generated method stub
				String a = text.getText();
				String b = a.substring(0, a.length() - 1);
				text.setText(b);
			}
		});
	    equ.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				// TODO Auto-generated method stub
				String string = text.getText().trim();
				int flag = Format_detection.isFormate(string);
				
				if(flag == 0) {
					JOptionPane.showMessageDialog(null, "输入为空，请输入算式","警告",JOptionPane.ERROR_MESSAGE);
				}else if(flag == 1) {
					JOptionPane.showMessageDialog(null, "算式格式错误，请输入正确格式的算式","警告",JOptionPane.ERROR_MESSAGE);
					
				}else {
					getResult result = new getResult(string);
					resulttext.setText(result.result_int+"");
				}
				
				}	
		});
	}
	//各按钮的时间处理方法
	public void Text(JButton button){
		button.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent arg0) {
				// TODO Auto-generated method stub
				String str=button.getText();
				//System.out.println(str);
				text.setText(text.getText() + str);
			}
		});
	}
	public static void main(String[] args) {
		new calculator();
	}
}



由于我在写这个简易计算机器软件的时候是分不同模块写的，且代码量较多，所以我只是截取了界面的源码进行展示，至于完整的源码，我已上传至我的资源中，大家可以在我的资源中进行下载。

展开全部
import java.awt.BorderLayout;
import java.awt.GridLayout;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.text.DecimalFormat;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextField;
public class Calculator {
//计算器面板e69da5e887aa62616964757a686964616f31333330326130
private JFrame f = new JFrame("Calculator");
//输入面扳
private JPanel inputPanel = new JPanel();
//加减乘除面板
private JPanel operationPanel = new JPanel();
//数字面板
private JPanel buttonsPanel = new JPanel();
//输入数据文本框
private JTextField input = new JTextField(20);
//退格键
private JButton backspace = new JButton("BackSpace");
//清空
private JButton CE = new JButton("CE  ");
//删除
private JButton C = new JButton("C  ");
//四则运算符号键
private JButton add = new JButton("+");
private JButton sub = new JButton("-");
private JButton mul = new JButton("*");
private JButton div = new JButton("/");
//小数点
private JButton decimal = new JButton(".");
//等号
private JButton equal = new JButton("=");
//数字键
private JButton zero = new JButton("0");
private JButton one = new JButton("1");
private JButton two = new JButton("2");
private JButton three = new JButton("3");
private JButton four = new JButton("4");
private JButton five = new JButton("5");
private JButton six = new JButton("6");
private JButton seven = new JButton("7");
private JButton eight = new JButton("8");
private JButton nine = new JButton("9");
private String num1 = "";//保存第一个运算数字
private String operator = "";//保存运算符号
public static void main(String[] args) {
new Calculator();//new计算器实例
}
public Calculator(){
//添加组件，布局
inputPanel.add(input);
f.add(inputPanel, BorderLayout.NORTH);
operationPanel.add(backspace);
operationPanel.add(CE);
operationPanel.add(C);
f.add(operationPanel, BorderLayout.CENTER);
buttonsPanel.add(add);
buttonsPanel.add(sub);
buttonsPanel.add(mul);
buttonsPanel.add(div);
buttonsPanel.add(one);
buttonsPanel.add(two);
buttonsPanel.add(three);
buttonsPanel.add(zero);
buttonsPanel.add(four);
buttonsPanel.add(five);
buttonsPanel.add(six);
buttonsPanel.add(decimal);
buttonsPanel.add(seven);
buttonsPanel.add(eight);
buttonsPanel.add(nine);
buttonsPanel.add(equal);
buttonsPanel.setLayout(new GridLayout(4, 4));
f.add(buttonsPanel, BorderLayout.SOUTH);
//注册各个组件监听事件
backspace.addMouseListener(new OperationMouseListener());
CE.addMouseListener(new OperationMouseListener());
C.addMouseListener(new OperationMouseListener());
decimal.addMouseListener(new OperationMouseListener());
equal.addMouseListener(new OperationMouseListener());
//注册四则运算监听
add.addMouseListener(new CalcMouseListener());
sub.addMouseListener(new CalcMouseListener());
mul.addMouseListener(new CalcMouseListener());
div.addMouseListener(new CalcMouseListener());
//注册数字监听事件
zero.addMouseListener(new NumberMouseListener());
one.addMouseListener(new NumberMouseListener());
two.addMouseListener(new NumberMouseListener());
three.addMouseListener(new NumberMouseListener());
four.addMouseListener(new NumberMouseListener());
five.addMouseListener(new NumberMouseListener());
six.addMouseListener(new NumberMouseListener());
seven.addMouseListener(new NumberMouseListener());
eight.addMouseListener(new NumberMouseListener());
nine.addMouseListener(new NumberMouseListener());
f.setVisible(true);
f.pack();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
private class NumberMouseListener implements MouseListener{
public void mouseClicked(MouseEvent e) {
if(input.getText().trim().equals("0")){//如果文本框已经是0，结果还是0
input.setText(((JButton)e.getSource()).getText().trim());
}else{//否则的话，把0添加到后面，譬如文本框是1，结果就为10
input.setText(input.getText().concat(((JButton)e.getSource()).getText().trim()));
}
}
public void mouseEntered(MouseEvent e) {}
public void mouseExited(MouseEvent e) {}
public void mousePressed(MouseEvent e) {}
public void mouseReleased(MouseEvent e) {}
}
private class CalcMouseListener implements MouseListener{
//如果输入的是运算符号，保存第一个结果和运算符号
public void mouseClicked(MouseEvent e) {
num1 = input.getText().trim();input.setText("");
operator = ((JButton)e.getSource()).getText().trim();
}
public void mouseEntered(MouseEvent e) {}
public void mouseExited(MouseEvent e) {}
public void mousePressed(MouseEvent e) {}
public void mouseReleased(MouseEvent e) {}
}
private class OperationMouseListener implements MouseListener{
public void mouseClicked(MouseEvent e) {
if(e.getSource() == backspace){//退格键，删除一个直到没有字符删除
String inputText = input.getText();
if(inputText.length() > 0){
input.setText(inputText.substring(0, inputText.length() - 1));
}
}else if(e.getSource() == C){
input.setText("0");//C，清空所有运算数字和符号
num1 = "";
}else if(e.getSource() == CE){
input.setText("0");//CE-->将文本框置为0
}else if(e.getSource() == decimal){
String text = input.getText().trim();
//如果按了小数点，如果文本框已经有小数点，不做任何操作，否则在结果后面加上小数点
if(text.indexOf(".") == -1){
input.setText(text.concat("."));
}
}else if(e.getSource() == equal){
//如果是等号
if(!operator.trim().equals("")){
if(!input.getText().trim().equals("")){
double result = 0D;
if(operator.equals("+")){//执行加法运算
result = Double.parseDouble(num1) + Double.parseDouble(input.getText().trim());
}else if(operator.equals("-")){//减法运算
result = Double.parseDouble(num1) - Double.parseDouble(input.getText().trim());
}else if(operator.equals("*")){//乘法运算
result = Double.parseDouble(num1) * Double.parseDouble(input.getText().trim());
}else if(operator.equals("/")){//除法运算
result = Double.parseDouble(num1) / Double.parseDouble(input.getText().trim());
}
//格式化最终结果，保留两位小数点
input.setText(new DecimalFormat("0.00").format(result));
}
}
}
}
public void mouseEntered(MouseEvent e) {}
public void mouseExited(MouseEvent e) {}
public void mousePressed(MouseEvent e) {}
public void mouseReleased(MouseEvent e) {}
}
}
已赞过
已踩过<
你对这个回答的评价是？
评论
收起

初学java，试着写了一个小程序，可能有很多不足，希望大家多多见谅。
import java.util.Scanner;
public class Demo04 {
    public static void main(String[] args) {
        while (true) {
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入要操作的选项：1 加法 2 减法 3 乘法 4 除法");
            String s = scanner.next();
            char select = s.charAt(0);
            switch (select) {
                case '1':
                    System.out.println("请输入第一个数：");
                    double a = scanner.nextDouble();
                    System.out.println("请输入第二个数：");
                    double b = scanner.nextDouble();
                    double sum = add(a, b);
                    System.out.println("两个数的和为:" + sum);
                    break;
                case '2':
                    System.out.println("请输入被减数：");
                    double c = scanner.nextDouble();
                    System.out.println("请输入减数：");
                    double d = scanner.nextDouble();
                    double difference = reduce(c, d);
                    System.out.println("两个数的差为:" + difference);
                    break;
                case '3':
                    System.out.println("请输入第一个数：");
                    double e = scanner.nextDouble();
                    System.out.println("请输入第二个数：");
                    double f = scanner.nextDouble();
                    double ride = ride(e, f);
                    System.out.println("两个数的积为:" + ride);
                    break;
                case '4':
                    System.out.println("请输入被除数：");
                    double g = scanner.nextDouble();
                    System.out.println("请输入除数：");
                    double h = scanner.nextDouble();
                    double except = except(g, h);
                    System.out.println("两个数的商为:" + except);
                default:
                    System.out.println("你的输入有误，请重新输入：");
                    continue;
            }
            System.out.println("是否继续？是请输入Y，输入其他退出");
            String input = scanner.next();
            char go = input.charAt(0);
            if (go != 'Y'){
                break;
            }
        }
        }
    public static double add(double a,double b){
        return a + b;
    }
    public static double reduce(double a,double b){
        return a - b;
    }
    public static double ride(double a,double b){
        return a * b;
    }
    public static double except(double a,double b){
        return a / b;
    }
}

运行结果：

发现了大学时候写的计算器小程序，还有个图形界面，能够图形化展示表达式语法树，哈哈;)
只有200行Java代码，不但能够计算加减乘除，还能够匹配小括号~
代码点评：
从朴素的界面配色到简单易懂错误提示，无不体现了“用户体验”至上的设计理念；代码异常处理全面合理、滴水不漏，代码缩进优雅大方，变量命名直观易懂；再结合长度适中简单明了的注释，程序整体给人一种清新脱俗之感。背后不难看出作者对学习的热爱以及对设计的苛求，工匠精神可见一斑，真可谓是大学数据结构学以致用的典范！
实现代码如下所示：
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.TextField;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.util.Stack;
import javax.swing.JFrame;
/** * 图形界面的计算器程序，只能计算加减乘除， * 算式中可以有小括号。数字可以是小数 */
public class CalcGUI extends JFrame{
private static final long serialVersionUID = 1L;
private TreeNode resultTree;
private String textFieldString;
private boolean calcSuccess = true;
private char ops[][] = {
{'>', '>', '', '>'},
{'>', '>', '', '>'},
{'>', '>', '>', '>', '', '>'},
{'>', '>', '>', '>', '', '>'},
{'
{'E', 'E', 'E', 'E', 'E', 'E', 'E'},
{'
};
Stack nodesStack = new Stack();
Stack opsStack = new Stack();
publicstaticvoidmain(String[] args) {
CalcGUI gui = new CalcGUI();
gui.userGUI();
}
publicvoiduserGUI(){
this.setLayout(new BorderLayout());
TextField tf = new TextField("请输入表达式，按Enter开始计算~", 40);
tf.selectAll();
tf.getText();
tf.addKeyListener(new KeyAdapter(){
publicvoidkeyPressed(KeyEvent e){
if(e.getKeyCode() == KeyEvent.VK_ENTER){
textFieldString = ((TextField)e.getComponent()).getText();
calcSuccess = true;
resultTree = null;
try{
resultTree = calc(textFieldString + "#");
}catch(Exception e1){
calcSuccess = false;
}
CalcGUI.this.repaint();
}
}
});
this.add(tf, BorderLayout.NORTH);
this.setSize(500, 500);
this.setTitle("calc GUI");
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setResizable(true);
this.setVisible(true);
}
private int levelHeight = 60;
private int diameter = 25;
publicvoidpaint(Graphics g){
super.paint(g);
if(calcSuccess){
if(resultTree != null){
g.drawString("计算结果为：" + resultTree.value, 10, 80);
int rootBeginX = this.getWidth() / 2;
int rootBeginY = 100;
Point p = new Point(rootBeginX, rootBeginY);
drawTree(g, resultTree, p, this.getWidth() / 2 - 20, p);
}
}else{
g.setColor(Color.RED);
g.drawString("表达式语法有误！", 10, 80);
}
}
privatevoiddrawCircle(Graphics g, Point p, int r){
g.drawOval(p.x - r, p.y - r, r * 2, r * 2);
}
privatevoiddrawTree(Graphics g, TreeNode node, Point pme, int width, Point pfather){
if(node == null) return;
//   System.out.println("in drawTree, node.value=" + node.value + ",node.op=" + node.op);
g.setColor(Color.GREEN);
this.drawCircle(g, pme, diameter / 2);
g.drawLine(pme.x, pme.y, pfather.x, pfather.y);
if(node.op != 'E'){
g.setColor(Color.BLACK);
g.drawString(String.valueOf(node.op), pme.x, pme.y);
}else{
g.setColor(Color.BLACK);
g.drawString(String.valueOf(node.value), pme.x - diameter / 2, pme.y);
}
drawTree(g, node.lft, new Point(pme.x - width / 2, pme.y + levelHeight), width / 2, pme);
drawTree(g, node.rt, new Point(pme.x + width / 2, pme.y + levelHeight), width / 2, pme);
}
public TreeNode calc(String inStr) throws Exception{
opsStack.push('#');
StringBuilder buf = new StringBuilder();
int i = 0;
while(i < inStr.length()){
if(Character.isDigit(inStr.charAt(i)) || inStr.charAt(i) == '.'){// number
buf.delete(0, buf.length());
while(i < inStr.length() &&
(Character.isDigit(inStr.charAt(i)) || inStr.charAt(i) == '.'))
buf.append(inStr.charAt(i++));
Double number = Double.parseDouble(buf.toString());
nodesStack.push(new TreeNode(number));
}else if(inStr.charAt(i) == ' '){
i++;
continue;
}else{// operation
char op = inStr.charAt(i);
int subNew = getSub(op);
boolean goOn = true;
while(goOn){
if(opsStack.isEmpty())
throw new Exception("运算符太少！");
char opFormer = opsStack.peek();
int subFormer = getSub(opFormer);
switch(ops[subFormer][subNew]){
case '=':
goOn = false;
opsStack.pop();
break;
case '
goOn = false;
opsStack.push(op);
break;
case '>':
goOn = true;
TreeNode n1 = nodesStack.pop();
TreeNode n0 = nodesStack.pop();
double rs = doOperate(n0.value, n1.value, opFormer);
nodesStack.push(new TreeNode(rs, opFormer, n0, n1));
opsStack.pop();
break;
default:
throw new Exception("没有匹配的操作符：" + op);
}
}
i++;
}
}
return nodesStack.pop();
}
privatedoubledoOperate(double n0, double n1, char op) throws Exception{
switch(op){
case '+': return n0 + n1;
case '-': return n0 - n1;
case '*': return n0 * n1;
case '/': return n0 / n1;
default: throw new Exception("非法操作符：" + op);
}
}
privateintgetSub(char c){
switch(c){
case '+': return 0;
case '-': return 1;
case '*': return 2;
case '/': return 3;
case '(': return 4;
case ')': return 5;
case '#': return 6;
default : return -1;
}
}
}
class TreeNode{
public double value;
public char op = 'E';
public TreeNode lft;
public TreeNode rt;
public TreeNode(double value){
this.value = value;
}
public TreeNode(double value, char op, TreeNode lft, TreeNode rt){
this.value = value;
this.op = op;
this.lft = lft;
this.rt = rt;
}
StringBuilder buf = new StringBuilder();
public String toString(){
out(this);
return buf.toString();
}
privatevoidout(TreeNode node){
if(node == null) return;
out(node.lft);
if(node.op != 'E')
buf.append(node.op);
else
buf.append(node.value);
out(node.rt);
}
}
总结
以上所述是小编给大家介绍的200行Java代码编写一个计算器程序，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对脚本之家的支持！