其实java计算器源代码的问题并不复杂，但是又很多的朋友都不太了解java计算器程序代码，因此呢，今天小编就来为大家分享java计算器源代码的一些知识，希望可以帮助到大家，下面我们一起来看看这个问题的分析吧！
作为一名Java程序员，编写一个计算器可以说是最基础的实践之一。通过编写计算器源代码，我们可以深入了解Java的基本语法、数据类型、运算符以及控制结构等知识。本文将带领大家从入门级到进阶，一步步完成一个功能齐全的Java计算器。
一、计算器功能分析
在编写计算器之前，我们需要明确计算器的基本功能：
1. 加法：将两个数相加。
2. 减法：将一个数减去另一个数。
3. 乘法：将两个数相乘。
4. 除法：将一个数除以另一个数（除数不能为0）。
二、入门级计算器源代码
下面是一个简单的入门级Java计算器源代码：
“`java
import java.util.Scanner;
public class Calculator {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println(“
求JAVA计算器源代码!!!
class Calculator extends WindowAdapter implements ActionListener//创建Calculator类,实现ActionListener接口.
{
//result代表上一次运算结果；data1代表当前文本框内显示的数，radixPointDepth代表小数位数
private double result=0,data1=0,radixPointDepth=3;
//resultIndicate代表是否敲击了等号，要求结果
//radixPointIndicate代表是否敲击了小数点
private boolean radixPointIndicate=false,resultIndicate=false;
private char prec='+';//代表当前运算符
private JFrame f;//创建窗口
private TextField tf;//创建文本框,用于存放结果
private Button b1,b2,b3,b4,b5,b6,b7,b8,b9,b10,b11,b12,b13,b14,b15,b16,b17;//创建按钮
private Panel p;//创建/面板容器
public void init()
{
f=new JFrame(“计算器”);
p=new Panel();//运算界面p
p.setLayout(new GridLayout(4,4));//设置p的布局为GridLayout,四行四列
tf=new TextField(30);
//实例化按钮
b1=new Button(“7”);
b2=new Button(“8”);
b3=new Button(“9”);
b4=new Button(“+”);
b5=new Button(“4”);
b6=new Button(“5”);
b7=new Button(“6”);
b8=new Button(“-“);
b9=new Button(“1”);
b10=new Button(“2”);
b11=new Button(“3”);
b12=new Button(“*”);
b13=new Button(“0”);
b14=new Button(“.”);
b15=new Button(“=”);
b16=new Button(“/”);
b17=new Button(“清零”);
f.add(tf,”North”);//把文本区域添加到框架的上方
f.add(p,”Center”);//把面版添加到框架的中间
f.add(b17,”South”);//把按钮（清零）添加到框架的下方
//把按钮添加到面版上
p.add(b1);
p.add(b2);
p.add(b3);
p.add(b4);
p.add(b5);
p.add(b6);
p.add(b7);
p.add(b8);
p.add(b9);
p.add(b10);
p.add(b11);
p.add(b12);
p.add(b13);
p.add(b14);
p.add(b15);
p.add(b16);
//为按钮添加监听
b1.addActionListener(this);
b2.addActionListener(this);
b3.addActionListener(this);
b4.addActionListener(this);
b5.addActionListener(this);
b6.addActionListener(this);
b7.addActionListener(this);
b8.addActionListener(this);
b9.addActionListener(this);
b10.addActionListener(this);
b11.addActionListener(this);
b12.addActionListener(this);
b13.addActionListener(this);
b14.addActionListener(this);
b15.addActionListener(this);
b16.addActionListener(this);
b17.addActionListener(this);
f.addWindowListener(this);//为框架添加监听
f.setSize(300,190);//设置框架的大小
f.setVisible(true);//设置框架为可见
}
//监听程序，监听actionEvent事件
public void actionPerformed(ActionEvent e)
{
String s;
s=e.getActionCommand();//s存放敲击的命令字符串
//SWITCH开关
switch(s.charAt(0))
{
case'0':
case'1':
case'2':
case'3':
case'4':
case'5':
case'6':
case'7':
case'8':
case'9'://按了“0-9”，就执行下面
if(resultIndicate)//如果敲过等号，直接敲数字，则代表一个新运算开始了，所有内容初始化
{
result=0;
data1=0;
prec='+';
}
Integer Int1=new Integer(s);
if(radixPointIndicate)//如果敲击过小数点
{
radixPointDepth=radixPointDepth/10;
data1=data1+(Int1.intValue())*radixPointDepth;
}
else
{
data1=data1*10+(Int1.intValue());
}
Double displayNumber=new Double(data1);
tf.setText(displayNumber.toString());
resultIndicate=false;//只要敲击了数字键，就代表新的结果还没有算出来，所以为false
break;
case'+':
case'-':
case'*':
case'/':
case'='://按了“+、-、*、/”，执行下面
if(s.charAt(0)!='='&&resultIndicate)
//如果敲击+、-、*、/,并且已经计算过结果，则取新的操作符，所以为false；代表连续运算
//prec存放新敲击的运算符
{
prec=s.charAt(0);
resultIndicate=false;
}
else
{
//用SWITCH开关运算出执行了“+、-、*、/”的结果
switch(prec)
{
case'+':
result=result+data1;
break;
case'-':
result=result-data1;
break;
case'*':
result=result*data1;
break;
case'/':
result=result/data1;
break;
}
}
radixPointIndicate=false;//如果敲击运算符或者=，则认为一个运算数的终结；所以小数点要清空
radixPointDepth=1;
displayNumber=new Double(result);//将最新的计算结果显示在文本框内
tf.setText(displayNumber.toString());
//监听是否按了“=”
if(s.charAt(0)!='=')//如果没有敲等号，则敲了+、-、*、/，那么data1清空
{
data1=0;
prec=s.charAt(0);
}
else
{
resultIndicate=true;//resultIndicate只有当敲击了等号，才为true，否则为false
}
break;
case'.':
radixPointIndicate=true;
break;
}
//监听是否按了为“清零”,是则对各数据清零
if(s.equals(“清零”))
{
result=0;
data1=0;
radixPointDepth=1;
tf.setText(“”);
}
}
用JAVA编写的科学计算器源代码
这个你参考一下。
import javax.swing.*;
//import javax.swing.event.*;
import java.awt.*;
import java.awt.event.*;
//计算器显示结果的窗体
class Result extends JPanel
{
JTextField text= new JTextField(“0”);//text先是输入和结果
Result()
{
text.setHorizontalAlignment(SwingConstants.RIGHT);//讲输入的数字或得到的结果在text的右边显示
text.setEnabled(false);//文本框不能编辑
setLayout(new BorderLayout());//设定布局管理器边框布局
add(text, BorderLayout.CENTER);//text放置在窗体的中间
}
}
//计算器数字按钮定义面板
class Number_Key extends JPanel
{
JButton zero= new JButton(“0”);//数字键0
JButton one= new JButton(“1”);//数字键1
JButton two= new JButton(“2”);//数字键2
JButton three= new JButton(“3”);//数字键3
JButton four= new JButton(“4”);//数字键4
JButton five= new JButton(“5”);//数字键5
JButton six= new JButton(“6”);//数字键6
JButton seven= new JButton(“7”);//数字键7
JButton eight= new JButton(“8”);//数字键8
JButton nine= new JButton(“9”);//数字键9
JButton plus= new JButton(“+”);
JButton sub= new JButton(“-“);
JButton mul= new JButton(“*”);
JButton div= new JButton(“/”);
JButton equal= new JButton(“=”);
JButton ce= new JButton(“ce”);//置零键
JButton point= new JButton(“.”);
JButton tzero= new JButton(“00”);
Number_Key()
{
setLayout(new GridLayout(6, 3, 10, 10));//定义布局管理器为网格布局
//添加各个按钮键
add(seven);
add(eight);
add(nine);
add(four);
add(five);
add(six);
add(one);
add(two);
add(three);
add(zero);
add(tzero);
add(plus);
add(sub);
add(mul);
add(div);
add(point);
add(equal);
add(ce);
}
}
//计算器主类
class sakura extends JFrame implements ActionListener
{
Result result= new Result();//定义text的面板
Number_Key number_key= new Number_Key();//定义按钮面板
//当点击按钮+、-、*、/时，com= true
boolean com= false;
//当i=0时说明是我们第一次输入，字符串sum不会累加
int i= 0;
//存放text的内容
String sum=””;
//存放点击按钮+、-、*、/之前的数值
double total= 0;
//+、-、*、/的代号分别为1，2，3，4
int symbol= 0;
sakura()
{
super(“Calculator”);//设定标题
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设定关闭窗体时退出程序
JPanel pane= new JPanel();//定义主面板
pane.setLayout(new BorderLayout());
pane.add(result, BorderLayout.NORTH);
pane.add(number_key, BorderLayout.SOUTH);
number_key.one.addActionListener(this);//对1按钮添加监听事件
number_key.two.addActionListener(this);//对2按钮添加监听事件
number_key.three.addActionListener(this);//对3按钮添加监听事件
number_key.four.addActionListener(this);//对4按钮添加监听事件
number_key.five.addActionListener(this);//对5按钮添加监听事件
number_key.six.addActionListener(this);//对6按钮添加监听事件
number_key.seven.addActionListener(this);//对7按钮添加监听事件
number_key.eight.addActionListener(this);//对8按钮添加监听事件
number_key.nine.addActionListener(this);//对9按钮添加监听事件
number_key.zero.addActionListener(this);//对0按钮添加监听事件
number_key.ce.addActionListener(this);//对置零按钮添加监听事件
number_key.plus.addActionListener(this);//对+按钮添加监听事件
number_key.equal.addActionListener(this);//对=按钮添加监听事件
number_key.sub.addActionListener(this);//对-按钮添加监听事件
number_key.mul.addActionListener(this);//对*按钮添加监听事件
number_key.div.addActionListener(this);//对/按钮添加监听事件
number_key.tzero.addActionListener(this);//对00按钮添加监听事件
number_key.point.addActionListener(this);//对.按钮添加监听事件
setContentPane(pane);
pack();//初始化窗体大小为正好盛放所有按钮
}
//各个按钮触发的事件
public void actionPerformed(ActionEvent e){
/*如果是点击数字按钮那么先要判断是否在此之前点击了+、-、*、/、=，如果是那么com=true
*如果没有com= false;或者是否点击数字键，如果是i= 1,如果没有 i= 0;
**/
if(e.getSource()== number_key.one)
{
if(com|| i== 0)
{
result.text.setText(“1”);
com= false;
i= 1;
}
else
{
sum= result.text.getText();
result.text.setText(sum+”1″);
}
}
else if(e.getSource()== number_key.two)
{
if(com|| i== 0)
{
result.text.setText(“2”);
com= false;
i= 1;
}
else
{
sum= result.text.getText();
result.text.setText(sum+”2″);
}
}
else if(e.getSource()== number_key.three)
{
if(com|| i== 0)
{
result.text.setText(“3”);
com= false;
i= 1;
}
else
{
sum= result.text.getText();
result.text.setText(sum+”3″);
}
}
else if(e.getSource()== number_key.four)
{
if(com|| i== 0)
{
result.text.setText(“4”);
com= false;
i= 1;
}
else
{
sum= result.text.getText();
result.text.setText(sum+”4″);
}
}
else if(e.getSource()== number_key.five)
{
if(com|| i== 0)
{
result.text.setText(“5”);
com= false;
i= 1;
}
else
{
sum= result.text.getText();
result.text.setText(sum+”5″);
}
}
else if(e.getSource()== number_key.six)
{
if(com|| i== 0)
{
result.text.setText(“6”);
com= false;
i= 1;
}
else
{
sum= result.text.getText();
result.text.setText(sum+”6″);
}
}
else if(e.getSource()== number_key.seven)
{
if(com|| i== 0)
{
result.text.setText(“7”);
com= false;
i= 1;
}
else
{
sum= result.text.getText();
result.text.setText(sum+”7″);
}
}
else if(e.getSource()== number_key.eight)
{
if(com|| i== 0)
{
result.text.setText(“8”);
com= false;
i= 1;
}
else
{
sum= result.text.getText();
result.text.setText(sum+”8″);
}
}
else if(e.getSource()== number_key.nine)
{
if(com|| i== 0)
{
result.text.setText(“9”);
com= false;
i= 1;
}
else
{
sum= result.text.getText();
result.text.setText(sum+”9″);
}
}
/*对于0这个按钮有一定的说法，在我的程序里不会出现如00000这样的情况，我加了判断条件就是
*如果text中的数值=0就要判断在这个数值中是否有.存在?如果有那么就在原来数值基础之上添
*加0;否则保持原来的数值不变
*/
else if(e.getSource()== number_key.zero)
{
if(com|| i== 0)
{
result.text.setText(“0”);
com= false;
i= 1;
}
else
{
sum= result.text.getText();
if(Float.parseFloat(sum)> 0|| Float.parseFloat(sum)< 0)
{
result.text.setText(sum+”0″);
}
else
{
if(sum.trim().indexOf(“.”)==-1)
{
result.text.setText(sum);
}
else
{
result.text.setText(sum+”0″);
}
}
}
}
else if(e.getSource()== number_key.ce)
{
result.text.setText(“0”);
i= 0;
com= true;
}
else if(e.getSource()== number_key.tzero)
{
if(com|| i== 0)
{
result.text.setText(“0”);
com= false;
i= 1;
}
else
{
sum= result.text.getText();
if(Float.parseFloat(sum)> 0|| Float.parseFloat(sum)< 0)
{
result.text.setText(sum+”00″);
}
else
{
if(sum.trim().indexOf(“.”)==-1)
{
result.text.setText(sum);
}
else
{
result.text.setText(sum+”00″);
}
}
}
}
/*本程序不会让一个数值中出现2个以上的小数点.具体做法是:判断是否已经存在.存在就不添加,
*不存在就添加.
*/
else if(e.getSource()== number_key.point)
{
if(com|| i== 0)
{
result.text.setText(“0.”);
com= false;
i= 1;
}
else
{
sum= result.text.getText();
if(sum.trim().indexOf(“.”)==-1)
{
result.text.setText(sum+”.”);
}
else
{
result.text.setText(sum);
}
}
}
//获得点击+之前的数值
else if(e.getSource()== number_key.plus)
{
com= true;
i= 0;
total= Double.parseDouble(result.text.getText());
symbol= 1;
}//获得点击-之前的数值
else if(e.getSource()== number_key.sub)
{
com= true;
i= 0;
total= Double.parseDouble(result.text.getText());
symbol= 2;
}//获得点击*之前的数值
else if(e.getSource()== number_key.mul)
{
com= true;
i= 0;
total= Double.parseDouble(result.text.getText());
System.out.println(total);
symbol= 3;
}//获得点击/之前的数值
else if(e.getSource()== number_key.div)
{
com= true;
i= 0;
total= Double.parseDouble(result.text.getText());
symbol= 4;
}
else if(e.getSource()== number_key.equal)
{
switch(symbol)
{
case 1://计算加法
{
double ad=
total+ Double.parseDouble(result.text.getText());
result.text.setText(ad+””);
i= 0;
sum=””;
break;
}
case 2://计算减法
{
double ad=
total- Double.parseDouble(result.text.getText());
result.text.setText(String.valueOf(ad));
i= 0;
sum=””;
break;
}
case 3://计算乘法
{
double ad=
total* Double.parseDouble(result.text.getText());
result.text.setText(ad+””);
i= 0;
sum=””;
break;
}
case 4://计算除法
{
double ad=
total/ Double.parseDouble(result.text.getText());
result.text.setText(ad+””);
i= 0;
sum=””;
break;
}
}
System.out.println(com);
}
}
public static void main(String[] args)
{
sakura ww= new sakura();
ww.setVisible(true);
}
}
急求JAVA计算器源代码
目前只能做10以内的任何四则运算，如请输入四则运算表达式：8/2+6/3+(((6+4)*2)+0)/2
其结果为：16.0
目前这段代码有一个问题：无法进行10以上的计算，如计算：8/2+6/3+(((6+4)*2)+10)/2，则得不到正确的结果。
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Stack;
public class GetResult
{
public GetResult()
{
}
//判断是否为操作符，
//在ASCII码中，( is 40;)is 41;+ is 43;- is 45;* is 42;/ is 47
public boolean isOperator(int operator)
{
if(operator==40|| operator==41|| operator==43
|| operator==45||operator==42|| operator==47)
return true;
else
return false;
}
public int getPriority(int operator)
{
if(operator==43|| operator==45|| operator==40)
return 1;
else if(operator==42|| operator==47|| operator==41)
return 2;
else
return 0;
}
public static void main(String[] args)
{
//中序表达式
String inOrder=””;
//操作符堆栈，保存输入的四则表达式中的所有运算符
Stack<Character> operators=new Stack<Character>();
//存放用于计算结果的操作数
Stack<Float> numberStack=new Stack<Float>();
//用来遍历输入的中序表达式
int position=0;
//计算时，用来保存计算结果
float result=0;
//后序表达式
String postOrder=””;
//遍历后序表达式，存放后序表达式中的每个元素
List<Character> list=new ArrayList<Character>();
int forward=0;
System.out.print(“请输入四则运算表达式：”);
BufferedReader bur=new BufferedReader(new InputStreamReader(System.in));
try
{
inOrder=bur.readLine();
} catch(IOException e)
{
e.printStackTrace();
}
GetResult expression=new GetResult();
while(true)
{
//判断是否为操作符
if(expression.isOperator(inOrder.charAt(position)))
{
//第一种情况：判断操作符是否是（，如果是的话，就直接压入堆栈中；
//第二种情况：如果堆栈为空，也将操作符直接压入堆栈中。
if((char)inOrder.charAt(position)=='('|| operators.isEmpty())
{
operators.push(inOrder.charAt(position));
}
else
{
//如果操作符是），则输出堆栈中所有的操作符，直到取出（
if((char)inOrder.charAt(position)==')')
{
while(!operators.isEmpty()&& operators.peek()!=40)
postOrder+=operators.pop().toString();
operators.pop();
}
else
{
//比较操作符优先级，如果新的操作符优先级小于堆栈顶端操作符的优先级的话，则输出堆栈中所有的操作符
if(!operators.isEmpty()&& expression.getPriority((int)inOrder.charAt(position))<
expression.getPriority(operators.peek()))
{
while(!operators.isEmpty()&& operators.peek()!=40)
postOrder+=operators.pop().toString();
}
operators.push(inOrder.charAt(position));
}
}
}
else
postOrder+=inOrder.charAt(position);
position++;
if(position>inOrder.length()-1)
break;
}
//如果操作符堆栈中还有操作符，则直接输出。
while(!operators.isEmpty())
postOrder+=operators.pop().toString();
System.out.println(“后续表达式为：”+postOrder);
//将后序表达式转化为list表
for(int i=0;i<postOrder.length();i++)
{
char word=postOrder.charAt(i);
list.add(word);
}
//遍历后序表达式的list表
Iterator<Character> iter=list.iterator();
while(iter.hasNext())
{
char oper=iter.next();
//如果不是操作符，则直接压入堆栈中，用于后面的计算
if(!expression.isOperator(oper))
{
numberStack.push((float)oper-48);
}
//如果是操作符，则从操作数堆栈中取出两个操作数进行计算，
//计算后，再将结果压入堆栈中。
else
{
float number1=numberStack.pop();
float number2=numberStack.pop();
switch(oper)
{
case 43:
result=number2+number1;
numberStack.push(result);
break;
case 45:
result=number2-number1;
numberStack.push(result);
break;
case 42:
result=number2*number1;
numberStack.push(result);
break;
case 47:
if(number2%number1==0)
{
}
result=number2/number1;
numberStack.push(result);
break;
}
forward++;
if(forward>postOrder.length()-2)
break;
}
}
System.out.println(result);
}
}
好了，文章到这里就结束啦，如果本次分享的java计算器源代码和java计算器程序代码问题对您有所帮助，还望关注下本站哦！
