用java编写计算器

如何用栈编写计算器？~

一、需求分析
1、 功能：疏如一行表达式，若表达式有误，则输出“表达式有错” ，否则计算出表达式的值并输出。 运算符包括加、减、乘、除、乘方、一目减。 括号均为小括号，但可以层层嵌套。操作数可以是浮点数，也包括有多个字母组成的变量。
2、 输入的形式为表达式，按回车结束。输入值的范围不超过浮点数的范围。含有变量，变量名由字母组成，大小写不限。
3、 若计算结果为整数，则输出整数，若含有小数，则输出浮点数。
二、概要设计
1、 总体思路，先读入一行表达式，用一个字符数组存储。然后依次读每个字符，进行判断。边读入边进行计算。程序中用到了两个栈，一个字符栈以及一个数字栈，分别用来存储运算符和数字，根据运算符的优先顺序进行计算。最后输出结果。

2、程序包括几个模块，主函数和几个基本函数。
说明几个函数：
bool stackempty(save1 s)用来判断操作数栈s是否为空。
void push(save1 &s,char e)若栈满则输出“栈已满”，否则将元素e入栈
void pop(save1 &s, char &e)若栈为空则输出“栈为空”，否则将栈顶元素赋给e
bool stackempty2(save2 s)用来判断运算符栈s是否为空。
void push2(save2 &s, char e)若运算符栈满则输出“栈已满”，否则将元素e入栈
void pop2(save2 &s, char &e)若栈为空则输出“栈为空”，否则将栈顶元素赋给e
int in(char e)返回运算符e在栈内的优先级别
int out(char e) 返回运算符e在栈外的优先级别
void count(char a,char ope, char b)将a、b进行相应的运算，并将运算结果入栈
3、具体操作步骤：
1、先读入一行表达式，用一个字符数组line[]存储
2、依次读入每个字符并进行处理同是进行表达式判错：
1. 遇数字，则继续判断下一个字符，直到下一个字符不是数字且不是小数点，若该数含有两个小以上数点，则表示输入错误。否则即可保证该操作数是完整的浮点数，然后将该数入操作数栈。

若数字不是表达式的最后一位，且数字后面跟的不是“+、-、*、/、^、)”，则为表达式错误

2. 遇运算符，则分两种情况：
1、若运算符为负号（该运算符为符号的情况有两种：一为负号在最开头，一为符号前面是“（” ），则先将0入操作数栈，然后再将负号入运算符栈。
2、该运算符不是负号则与运算符栈的栈顶元素比：
(1) 若栈顶元素优先级低， 新输入的运算符入栈。
(2) 若栈顶元素优先级高，
1) 从符号栈弹出一个运算符，
2) 从对象栈弹出一个/两个操作数，
3) 运算结果压入对象栈。
(3) 优先级相等，则栈顶元素出栈，与输入元素对消。

若“(、+、-、*、/、^”放在表达式最后面，则表达式错误
若“+、-、*、/、^”后面跟的不是数字或者变量，表达式错误

3、遇字母变量，则继续判断下一个字符，直到下一个字符不是字母变量，即可保证该变量是完整的，然后输出“请输入变量的值”，再将输入的变量值入操作数栈。
若变量后面跟的不是“+、-、*、/、^、)”，则表达式错误
4、若所读的该字符不是上述情况中的一种，则表达式错误

3、当将所有的字符都读一遍之后，若表达式正确的话，则必然不含有“（”或者“）”。即若运算符栈中含有“（”或者“）”，则表达式必错误。 再考虑表达式正确的情况：运算符栈可能为空，则操作符栈中必剩下一个操作数，即最后的结果。若不为空，则留在运算符栈中的运算符的优先级别从栈顶至栈底依次递减。故可从运算符栈顶开始弹出一个运算符，从操作数栈中弹出两个操作数进行运算，再将运算结果入操作数栈，一直循环至运算符栈为空。此时操作数栈剩下的唯一一个操作数就是运算结果。

三、结论及体会
1、实验结论
a)、实验完成了题目的要求，自己添加了对浮点数的操作，并进行判错。
b)、编写代码基本上能够满足编程规范的要求，代码的变量命名，以及注释的书写，基本能按照要求进行。
b)、将数据结构中的队列和堆栈的知识复习到，并且学会创新，在代码的编写中，学习了编程规范，学习了结构化编程。

2、实验体会
a)、通过本设计实验将数据结构中的堆栈和队列的知识复习到，并且能够自己设计一些东西，学会了在设计实验过程时的基本步骤。基本上能够有条理的解决这些问题。
b)、在试验中遇到了很多的问题，都是以前没有发现的，这些问题设计的方面很多，有以前的C++基础的，也有最近学习的数据结构的知识。通过实验的设计，让我发现了自己的不足。自己在学习知识上面的漏洞。自己在细节方面的考虑还不够全面，很多细节都是通过调试才发现的。比如刚开始时忘了考虑变量之前有负号的情况以及将整个式子读一遍之后，栈中的操作数可能还有剩，还得继续进行计算等。希望通过弥补这些发现的漏洞，提高自己的专业知识水平。
c)、设计过程中的解决问题的方法，让我明白了如何学习会更有效。如何学习才不会耽误太多的时间。也学会了解决问题的一般方法：向老师、同学请教，借助网络等等。
d)、实验过程中也走了很多的弯路，由于在开始设计的时候思路不时很清晰，对于一些问题不能很好的提出解决问题的方法，在设计过程中，代码总是重复的修改，在很多问题上，代码并不时最优的。相信在以后的学习中，随着知识的增多，问题会逐渐得到解决。
四、程序源代码
#include
#include
#include
using namespace std;
#define MAX 1000

struct save1
{
float n[MAX];
int top;
}stack1;

struct save2
{
char n[MAX];
int top;
}stack2;
//stack1存储数字，stack2存储运算符号.

bool stackempty(save1 s)//判断是否为空
{
if (s.top== -1)
return 1;
else
return 0;
}

bool stackempty2(save2 s)//判断是否为空
{
if (s.top== -1)
return 1;
else
return 0;
}

void push(save1 &s,float e)//将e入栈
{
if(s.top==MAX-1)
{
cout<<"栈已满"<<endl;
return ;
}
s.top++;
s.n[s.top]=e;
}

void push2(save2 &s,char e)//将e入栈
{
if(s.top==MAX-1)
{
cout<<"栈已满"<<endl;
return ;
}
s.top++;
s.n[s.top]=e;
}

void pop(save1 &s,float &e)//将栈顶元素出栈，存到e中
{
if(s.top==-1)
{ cout<<"栈为空"<<endl; }
else
{e=s.n[s.top]; s.top--; }
}

void pop2(save2 &s,char &e)//将栈顶元素出栈，存到e中
{
if(s.top==-1)
{ cout<<"栈为空"<<endl; }
else
{e=s.n[s.top]; s.top--; }
}

int in(char e)//e在栈内的优先级别
{
if(e=='-' || e=='+') return 2;
if(e=='*' || e=='/') return 4;
if(e=='^') return 5;
if(e=='(') return 0;
if(e==')') return 7;
return -1;
}

int out(char e)//e在栈外的优先级别
{
if(e=='-' || e=='+') return 1;
if(e=='*' || e=='/') return 3;
if(e=='^') return 6;
if(e=='(') return 7;
if(e==')') return 0;
return -1;
}

void count(float a,char ope,float b)//进行计算并将计算结果入栈
{
float sum;
if(ope=='+') sum=a+b;
if(ope=='-') sum=a-b;
if(ope=='*') sum=a*b;
if(ope=='/') sum=a/b;
if(ope=='^') sum=pow(a,b);
push(stack1,sum);
}

int main()
{
int i=0,len,j,nofpoint,g=0;//len表示输入式子的长度。 g表示读入的字符是否是字母变量、数字以及运算符。
float a,b;//a、b用来存储操作数栈中弹出的操作数，便于代入函数中进行计算。
char line[MAX],operate,temp[20];
cout<<"请输入表达式"<<endl;
cin>>line;
len=strlen(line);
stack1.top=-1;//将栈置为空
stack2.top=-1;//将栈置为空
while(1)
{
g=0;
if(isdigit(line[i]))//若读入的字符为数字，则继续判断下一个字符，直到下一个字符不是数字或者不是小数点，即可保证该操作数是完整的小数，然后将该数入操作数栈。
{
j=0; g=1;
nofpoint=0;//记录所存的数中小数点的个数
while(isdigit(line[i]) || line[i]=='.')
{
if(line[i]=='.') nofpoint++;
temp[j++]=line[i];
i++;
if(i>=len) break;
}
if( nofpoint>1 || (i<len&&(line[i]!='-' && line[i]!='+' && line[i]!='*' && line[i]!='/' && line[i]!='^' && line[i]!=')')) )
{ cout<<"表达式有错"<<endl; return 0; }//所存数中含有不止一个小数点，或者数字后面跟的不是“+、-、*、/、^、)”，则为错误

temp[j]='\0';
b=atof(temp);
push(stack1,b);
if(i>=len) break;
}
else
{
if(line[i]=='-' || line[i]=='+' || line[i]=='*' || line[i]=='/' ||
line[i]=='^' || line[i]=='(' || line[i]==')' ) //若读入的字符为运算符的情况
{
g=1;
if(line[i]=='(' && i==len) { cout<<"表达式有错"<<endl; return 0; }// “(”放表达式最后面，错误
if(line[i]=='-' || line[i]=='+' || line[i]=='*' || line[i]=='/' || line[i]=='^')
{
if(i==len) { cout<<"表达式有错"<<endl; return 0; }//“+、-、*、/、^”放在表达式最后面，错误
if( (!isdigit(line[i+1])) && (!isalpha(line[i+1])) && line[i+1]!='(')//“+、-、*、/、^”后面跟的不是数字或者变量，错误
{ cout<<"表达式有错"<<endl; return 0; }
}

if(line[i]=='-' && (i==0 || line[i-1]=='(' ))//运算符是负号
{
push(stack1,0);
push2(stack2,line[i]);
i++;
}
else
{ //读入的运算符与运算符栈的栈顶元素相比，并进行相应的操作
if(in(stack2.n[stack2.top])<out(line[i])||stackempty2(stack2)) { push2(stack2,line[i]);i++;}
else
if(in(stack2.n[stack2.top])==out(line[i])) {i++; stack2.top--;}
else
if(in(stack2.n[stack2.top])>out(line[i]))
{
pop(stack1,a);
pop(stack1,b);
pop2(stack2,operate);
count(b,operate,a);
}
if(i>=len) break;
}
}
else
{
if(isalpha(line[i]))//读入的字符是字母变量的情况
{
g=1;
cout<<"请输入变量";
while( isalpha(line[i])) { cout<<line[i]; i++; }
cout<<"的值"<<endl;
cin>>b;
push(stack1,b);
if(i>=len) break;
if(line[i]!='-' && line[i]!='+' && line[i]!='*' && line[i]!='/' && line[i]!='^' && line[i]!=')')//变量后面跟的不是“+、-、*、/、^、)”，则为错误
{ cout<<"表达式有错"<<endl; return 0; }
}
}
}
if(g==0) { cout<<"表达式有错"<<endl; return 0; }//g=0表示该字符是不符合要求的字符
}

while(stack2.top!=-1)//读入结束后，继续进行操作，直到运算符栈为空
{
pop(stack1,a);
pop(stack1,b);
pop2(stack2,operate);
if(operate=='(' || operate==')') //括号多余的情况
{ cout<<"表达式有错"<<endl; return 0; }
count(b,operate,a);
}
cout<<stack1.n[stack1.top]<<endl;
return 0;
}

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.SwingConstants;
public class Jisuanqi extends JFrame implements ActionListener {
/**
*
*/
private static final long serialVersionUID = 1L;
Result result = new Result(); // 定义text的面板
Number_Key number_key = new Number_Key(); // 定义按钮面板
// 当点击按钮+、-、*、/时，com = true
boolean com = false;
// 当i=0时说明是我们第一次输入，字符串text不会累加
int i = 0;
// 存放text的内容
String text = "";
// 存放点击按钮+、-、*、/之前的数值
double defbutton = 0;
// +、-、*、/的代号分别为1，2，3，4
int symbol = 0;
// 构造函数
Jisuanqi() {
super("WangJiao"); // 设定标题
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // 设定关闭窗体时退出程序
JPanel pane = new JPanel(); // 定义主面板
pane.setLayout(new BorderLayout());
setBounds(380, 220, 30, 80); // 前两个参数是在屏幕上显示的坐标，后两个是大小
// 替换图标
ImageIcon icon = new ImageIcon("F:1.GIF");
// Jisuanqi.class.getResource("APPLE.GIF")
// );
setIconImage(icon.getImage());
pane.add(result, BorderLayout.NORTH);
pane.add(number_key, BorderLayout.CENTER);
pane.add(number_key.equal, 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.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 {
text = result.text.getText();
result.text.setText(text + "1");
}
} else if (e.getSource() == number_key.two) {
if (com || i == 0) {
result.text.setText("2");
com = false;
i = 1;
} else {
text = result.text.getText();
result.text.setText(text + "2");
}
} else if (e.getSource() == number_key.three) {
if (com || i == 0) {
result.text.setText("3");
com = false;
i = 1;
} else {
text = result.text.getText();
result.text.setText(text + "3");
}
} else if (e.getSource() == number_key.four) {
if (com || i == 0) {
result.text.setText("4");
com = false;
i = 1;
} else {
text = result.text.getText();
result.text.setText(text + "4");
}
} else if (e.getSource() == number_key.five) {
if (com || i == 0) {
result.text.setText("5");
com = false;
i = 1;
} else {
text = result.text.getText();
result.text.setText(text + "5");
}
} else if (e.getSource() == number_key.six) {
if (com || i == 0) {
result.text.setText("6");
com = false;
i = 1;
} else {
text = result.text.getText();
result.text.setText(text + "6");
}
} else if (e.getSource() == number_key.seven) {
if (com || i == 0) {
result.text.setText("7");
com = false;
i = 1;
} else {
text = result.text.getText();
result.text.setText(text + "7");
}
} else if (e.getSource() == number_key.eight) {
if (com || i == 0) {
result.text.setText("8");
com = false;
i = 1;
} else {
text = result.text.getText();
result.text.setText(text + "8");
}
} else if (e.getSource() == number_key.nine) {
if (com || i == 0) {
result.text.setText("9");
com = false;
i = 1;
} else {
text = result.text.getText();
result.text.setText(text + "9");
}
}
/*
* 对于0这个按钮有一定的说法，在我的程序里不会出现如00000这样的情况，我加了判断条件就是
* 如果text中的数值=0就要判断在这个数值中是否有.存在?如果有那么就在原来数值基础之上添 加0;否则保持原来的数值不变
*/
else if (e.getSource() == number_key.zero) { // result.text.getText()是得到text里内容的意思
if (com || i == 0) {
result.text.setText("0");
com = false;
i = 1;
} else {
text = result.text.getText();
if (Float.parseFloat(text) > 0 || Float.parseFloat(text) < 0) { // Float.parseFloat(text)就是类型转换了，下面都是一样
result.text.setText(text + "0");
} else {
if (text.trim().indexOf(".") == -1) {
result.text.setText(text);
} else {
result.text.setText(text + "0");
}
}
}
} else if (e.getSource() == number_key.ce) {
result.text.setText("0");
i = 0;
com = true;
// text = "";
defbutton = 0;
}
/*
* 本程序不会让一个数值中出现2个以上的小数点.具体做法是:判断是否已经存在.存在就不添加, 不存在就添加.
*/
else if (e.getSource() == number_key.point) {
if (com || i == 0) {
result.text.setText("0.");
com = false;
i = 1;
} else {
text = result.text.getText();
if (text.trim().indexOf(".") == -1) {
result.text.setText(text + ".");
} else {
result.text.setText(text);
}
}
} // 获得点击+之前的数值
else if (e.getSource() == number_key.plus) {
com = true;
i = 0;
defbutton = Double.parseDouble(result.text.getText());
symbol = 1;
} // 获得点击-之前的数值
else if (e.getSource() == number_key.sub) {
com = true;
i = 0;
defbutton = Double.parseDouble(result.text.getText());
symbol = 2;
} // 获得点击*之前的数值
else if (e.getSource() == number_key.mul) {
com = true;
i = 0;
defbutton = Double.parseDouble(result.text.getText());
System.out.println(defbutton);
symbol = 3;
} // 获得点击/之前的数值
else if (e.getSource() == number_key.div) {
com = true;
i = 0;
defbutton = Double.parseDouble(result.text.getText());
symbol = 4;
} else if (e.getSource() == number_key.equal) {
switch (symbol) {
case 1: { // 计算加法
double ad = defbutton
+ Double.parseDouble(result.text.getText());
result.text.setText(ad + "");
i = 0;
text = "";
break;
}
case 2: { // 计算减法
double ad = defbutton
- Double.parseDouble(result.text.getText());
result.text.setText(String.valueOf(ad));
i = 0;
text = "";
break;
}
case 3: { // 计算乘法
double ad = defbutton
* Double.parseDouble(result.text.getText());
result.text.setText(ad + "");
i = 0;
text = "";
break;
}
case 4: { // 计算除法
double ad = defbutton
/ Double.parseDouble(result.text.getText());
result.text.setText(ad + "");
i = 0;
text = "";
break;
}
}
System.out.println(com);
}
System.out.println(result.text.getText());
}
@SuppressWarnings("deprecation")
public static void main(String[] args) {
Jisuanqi loveyou = new Jisuanqi();
loveyou.show();
}
}
// 计算器数字按钮定义面板
class Number_Key extends JPanel {
/**
*
*/
private static final long serialVersionUID = 1L;
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("清零"); // 置零键
JButton point = new JButton(".");
Number_Key() {
setLayout(new GridLayout(4, 4, 1, 1)); // 定义布局管理器为网格布局
setBackground(Color.blue); // 设置背景颜色
// 添加按钮
add(one);
add(two);
add(three);
add(four);
add(five);
add(six);
add(seven);
add(eight);
add(nine);
add(zero);
add(plus);
add(sub);
add(mul);
add(div);
add(point);
add(equal);
add(ce);
}
}
// 计算器显示结果的窗体
class Result extends JPanel {
/**
*
*/
private static final long serialVersionUID = 1L;
// text先是输入和结果
JTextField text = new JTextField("0");
@SuppressWarnings("deprecation")
Result() { // 讲输入的数字或得到的结果在text的右边显示
text.setHorizontalAlignment(SwingConstants.RIGHT);
text.enable(false); // 文本框不能编辑
setLayout(new BorderLayout()); // 设定布局管理器边框布局
add(text, BorderLayout.CENTER); // text放置在窗体的中间
}
}
直接复制 保存成Jisuanqi .java可以直接运行了

import java.awt.*;
import java.awt.datatransfer.*;
import java.awt.event.*;
import java.util.*;
import java.io.*;

class Oper // 对一个含+ - * /字符串求值
{
public String operator(String s) {
boolean flag = true;
boolean flag2 = false;
int i, n = 0;
String chr = new String(), theta = "";
double number1 = 0, number2 = 0;
Stack oprstack = new Stack();
oprstack.push("=");
Stack opnstack = new Stack();
for (i = 0; i < s.length(); i++) {
chr = String.valueOf(s.charAt(i));
if (!chr.equals("+") && !chr.equals("-") && !chr.equals("*")
&& !chr.equals("/") && !chr.equals("(") && !chr.equals(")")
&& !chr.equals("s") && !chr.equals("=")) {
flag2 = true;
continue;
} else {
if (flag2 == true && chr.equals("s"))
return "您输入有误!";// 提示“数字+sqrt”式输入错误
flag2 = false;
if (n <= i - 1) // 解决+(问题
{
opnstack.push(s.substring(n, i));
}
n = i + 1;
flag = true;
while (flag) {
switch (precede(String.valueOf(oprstack.peek()), chr))// (String)oprstack.peek()
{
case 3:
oprstack.push(chr); // opr1<opr2
flag = false;
break;
case 2:
oprstack.pop(); // opr1==opr2()
flag = false;
break;
case 1:
theta = String.valueOf(oprstack.pop()); // opr1>opr2
if (theta.equals("s")) // 解决sqrt()问题
{
number1 = Double.parseDouble((String) (opnstack
.pop()));
opnstack.push(String.valueOf(Math.sqrt(number1)));
} else // 解决一般混合运算
{
number2 = Double.parseDouble((String) (opnstack
.pop()));
number1 = Double.parseDouble((String) (opnstack
.pop()));
opnstack.push(String.valueOf(opr(number1, number2,
theta)));
}
flag = true;
break;
case 0:
return "您输入有误!";
}// end switch
}// endwhile
}// endelse
}// endfor
return (String.valueOf(opnstack.pop()));
}// end operator()

public double opr(double x, double y, String theta) // 返回x与y运算值
{
if (theta.equals("+"))
return x + y;
if (theta.equals("-"))
return x - y;
if (theta.equals("*"))
return x * y;
if (theta.equals("/"))
return x / y;
return 0.;
}

public int precede(String chr, String c) // 判断运算符优先级
{
// 1 代表">" 2代表"=" 3代表"<"
if (chr.equals("+") || chr.equals("-")) {
if (c.equals("*") || c.equals("/") || c.equals("(")
|| c.equals("s"))
return 3;
else
return 1;
}
if (chr.equals("*") || chr.equals("/") || chr.equals("s")) {
if (c.equals("("))
return 3;
else
return 1;
}
if (chr.equals("(")) {
if (c.equals(")"))
return 2;
else
return 3;
}
if (chr.equals(")")) {
return 1;
}
if (chr.equals("=")) {
if (c.equals("="))
return 2;
else if (c.equals(")"))
return 0;// 提示括号不匹配式输入错误
else
return 3;
}
return 0;
}// end precede

}// end class oper

public class Calculator extends Frame implements ActionListener {
private String s_show;

private String s_go;

Panel p1 = new Panel();

Panel p2 = new Panel();
Panel p3=new Panel();

Oper do1 = new Oper();

TextField textfields = new TextField(27);
Dialog dlog=new Dialog(this,"about us");
Label aboutlab=new Label();
String s1;
String sedit;

Button buttons1 = new Button("Backspace");
int screenWidth,screenHeight;

Clipboard clp=Toolkit.getDefaultToolkit().getSystemClipboard();

Calculator() {
this.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
MenuBar mbr=new MenuBar();
setMenuBar(mbr);
Menu edit=new Menu(" do ");
MenuItem copy=new MenuItem("Copy Ctrl+C");
MenuItem zhantie=new MenuItem(" Ctrl+V");
MenuItem exit=new MenuItem("Close Alt+F4");
edit.add(copy);
edit.add(zhantie);
mbr.add(edit);
Menu help=new Menu(" help ");
MenuItem help1=new MenuItem("help theme");
MenuItem about=new MenuItem("about us");
dlog.setAlwaysOnTop(true);
dlog.setResizable(false);
//dlog.setEnabled(false);
s1="学习时兴趣小组做的";
aboutlab.setSize(200, 150);
aboutlab.setText(s1);
dlog.add(aboutlab);
about.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
dlog.setVisible(true);
}
});
dlog.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
dlog.setVisible(false);
}
});
help.add(help1);
help.add(about);
mbr.add(help);
p1.setBackground(Color.lightGray);
p1.setForeground(Color.red);
p2.setBackground(Color.lightGray);
p2.setForeground(Color.blue);
p1.setLayout(new FlowLayout(FlowLayout.RIGHT, 1,1));
p1.add(textfields);
p1.add(buttons1);
buttons1.addActionListener(this);
p2.setLayout(new GridLayout(5, 4, 10, 16));
this.add(p1, BorderLayout.CENTER);
this.add(p2, BorderLayout.SOUTH);
this.setTitle("Play the window");
this.setResizable(false);
this.setAlwaysOnTop(true);
/**textfields.addKeyListener(new KeyAdapter(){
public void keyTyped(KeyEvent e){
char c=e.getKeyChar();
String textfieldsstr=textfields.toString();
switch(c){
case 1:textfields.setText(textfieldsstr+1);break;
case 2:textfields.setText(textfields.toString()+2);break;
case 3:textfields.setText(textfields.toString()+3);break;
case 4:textfields.setText(textfields.toString()+4);break;
case 5:textfields.setText(textfields.toString()+5);break;
case 6:textfields.setText(textfields.toString()+6);break;
case 7:textfields.setText(textfields.toString()+7);break;
case 8:textfields.setText(textfields.toString()+8);break;
case 9:textfields.setText(textfields.toString()+9);break;
case 0:textfields.setText(textfields.toString()+0);break;
case '*':textfields.setText(textfields.toString()+"*");break;
}
/**if(e.getKeyChar()==1){
textfields.setText(textfields.toString()+1);
}
}
});*///未实现键盘监听
Toolkit tk=Toolkit.getDefaultToolkit();
Dimension screenSize = tk.getScreenSize();
screenWidth=screenSize.width;
screenHeight=screenSize.height;
this.setBounds(screenWidth/2-150, screenHeight/2-128, 300, 256);
dlog.setBounds(screenWidth/2-100, screenHeight/2-78, 200, 150);
int i, j = 0, k = 9, r1 = 0, r2 = 0, r3 = 0;
for (i = 0; i < 20; i++) {
j++;
if (j == 4) {
j = 0;
r1++;
Button buttons2_i = new Button();
p2.add(buttons2_i);
buttons2_i.setBackground(Color.cyan);
buttons2_i.addActionListener(this);
switch (r1) {
case 1:
buttons2_i.setLabel("+");
break;
case 2:
buttons2_i.setLabel("-");
break;
case 3:
buttons2_i.setLabel("*");
break;
case 4:
buttons2_i.setLabel("/");
break;
case 5:
buttons2_i.setLabel("=");
break;
}
}// endif
else // else1
{
if (i < 3) {
r2++;
Button buttons2_i = new Button(""); //

p2.add(buttons2_i);
buttons2_i.setBackground(Color.cyan);
buttons2_i.addActionListener(this);
switch (r2) {
case 1:
buttons2_i.setLabel("(");
break;
case 2:
buttons2_i.setLabel(")");
break;
case 3:
buttons2_i.setLabel("sqrt");
break;
}

}// endif
else {
if (i > 16 && i < 19) {
r3++;
Button buttons2_i = new Button("");
p2.add(buttons2_i);
buttons2_i.addActionListener(this);
switch (r3) {
case 1:
buttons2_i.setLabel(".");
break;
case 2:
buttons2_i.setLabel("CE");
break;
}
}// endif
else {
Integer name = new Integer(k);
k--;
s_show = name.toString();
Button buttons2_i = new Button(s_show);
p2.add(buttons2_i);
buttons2_i.addActionListener(this);
}
}
}// end else1
}// end for
s_show = "";
s_go = "";
this.setVisible(true);
}// end Calculator()构造方法

public void actionPerformed(ActionEvent e) {
if (e.getSource() instanceof Button) // if1
{
if (e.getActionCommand() == "CE")// Del
{
s_show = "";
s_go = "";
textfields.setText(s_show);
} else if (e.getActionCommand() == "Backspace") {
if (s_show.equals("")) {
s_go = "";
textfields.setText("");
} else {
if (s_go.length() > 0)
s_go = s_go.substring(0, s_go.length() - 1);
s_show = s_show.substring(0, s_show.length() - 1);
textfields.setText(s_show);
}
} else if (e.getActionCommand() == ".") {
if (textfields.getText().equals(""))
textfields.setText("0.");
else {
s_show += e.getActionCommand();
s_go += e.getActionCommand();
textfields.setText(s_show);
}
} else {
if (e.getActionCommand() != "=") {
if (e.getActionCommand().equals("sqrt")) {
s_show += e.getActionCommand();
s_go += e.getActionCommand();
textfields.setText(s_show);
s_go = s_go.substring(0, s_go.length() - 3);
} else {
s_show += e.getActionCommand();
s_go += e.getActionCommand();
textfields.setText(s_show);
}
} else {
s_show += e.getActionCommand();
s_go += e.getActionCommand();
textfields.setText(do1.operator(s_go)); // ().toString()
}
}// end else
}// end if1
if(e.getSource()=="copy"){
sedit=textfields.getSelectedText();
StringSelection text=new StringSelection(sedit);
clp.setContents(text, null);
}
/**else if(e.getSource()=="zhantie"){
Transferable contents=clp.getContents(this);//返回表示剪贴板当前内容的 transferable 对象。
DataFlavor flavor=DataFlavor.stringFlavor;//
String ss;
if (contents.isDataFlavorSupported(flavor)) {
try
{
int start=textfields.getSelectionStart();
int end=textfields.getSelectionEnd();
//textfields.replaceRange("",start,end);
textfields.setText(ss);
ss = (String)contents.getTransferData(flavor);
int n=textfields.getCaretPosition();
textfields.insert(ss,n);
}catch(Exception ee){

// TODO: handle exception
}
}
}*///未实现剪贴板粘贴功能
// end actionPerformed()
// end class Calculator
}

public static void main(String args[]) {
Calculator cal = new Calculator();
}
}

因为有字数限制， 发前半部分

package c;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Container;
import java.awt.FileDialog;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.GridLayout;
import java.awt.Image;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.image.MemoryImageSource;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Stack;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JPopupMenu;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.KeyStroke;
import javax.swing.LookAndFeel;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;
import javax.swing.border.EmptyBorder;
import javax.swing.event.CaretEvent;
import javax.swing.event.CaretListener;
import javax.swing.plaf.metal.MetalLookAndFeel;

import com.sun.java.swing.plaf.windows.WindowsLookAndFeel;

//该版本是改进版 01

/*///////////////////////////////////////////////////////
*
* @author T
*
* 主要实现了一个计算器框架,内含一个计算方法 calculate
*
* 通过实现包内的Calculator接口可以换成其他的运算方法
*
* 代码上半部分为界面实现,后半部分为表达式运算实现
*
*////////////////////////////////////////////////////////

//=======================================================================
//

//主要框架开始:

public class CalculatorFrame01 extends JFrame implements ActionListener, MouseListener{

//help窗口
class HelpFrame extends JFrame {

private static final long serialVersionUID = 5659419268287608878L;

private Color bkgd=new Color(0,32,68);
public HelpFrame(){
super("Help contents");
setSize(300,300);
setLocation(400,150);
setResizable(false);
setIconImage(icon);
}

public void paint(Graphics g){
g.setColor(bkgd);
g.fillRect(0, 0, 300, 300);
g.setColor(Color.white);
g.drawString("该版本采用的角度制是弧度",10, 60);
g.drawString("圆周率 PI = 3.141592653589793(直接输入PI即可)",10, 100);
g.drawString("自然对数 e = 2.718281828459045(直接输入e即可)",10, 140);
g.drawString("有任何疑问和建议请发至邮箱 talent-001@163.com", 10, 180);
g.drawString("衷心感谢", 130, 220);
g.drawString("By T", 240, 270);
}
}

//about窗口
class AboutFrame extends JFrame {

private static final long serialVersionUID = 5659419268287608877L;

public AboutFrame(){
super("About T's Calculator");
setSize(300,300);
setLocation(400,150);
setResizable(false);
setIconImage(icon);
}

public void paint(Graphics g){
g.setColor(Color.white);
g.drawImage(icon,0,10,300,300,null);
g.drawString("Author T", 200, 60);
g.drawString("E-mail talent-001@163.com",130, 100);
g.drawString("CreateTime 2009.4.23",150, 140);
g.drawString("Advised by ZzxBarry",160, 180);

g.drawString("Acknowledge Java2学习指南 Eclipse Ganymede",20, 240);

g.setColor(Color.gray);
g.drawString("ClassName CalculatorFrame01",110, 280);
}

}

private static final long serialVersionUID = 2087528703614679038L;
//
//
//
//==============================================================================
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//==============================================================================
//上半部分:界面实现
//
//
//==================================================================
//成员--数据域

//文件操作
private FileDialog filedialog = new FileDialog(this,"File");

//主要背景色
private Color backgroundColor = new Color(230,238,238);

//光标位置
private int caretDot;

//结果储存
private String answer="";

//输入,输出区域
public JTextField input = new JTextField(28);
public JTextArea output = new JTextArea(6,33);

//输出区域的滚动窗格
private JScrollPane outPane =new JScrollPane(output);

//窗口容器
private Container mainPane=this.getContentPane();

//右键弹出菜单
private JPopupMenu popupMenu = new JPopupMenu();

//platform look and feel
private LookAndFeel plaf = UIManager.getLookAndFeel();

//图标
public Image icon;

//Help contents
public JFrame help;

//About T's Calculator
public JFrame about;

//计算器数据
//计算器引用,默认初始化为自身
public Calculator calculator = this;

//=====================================================================
//成员--构造器

//默认构造函数
public CalculatorFrame01(){
super("T Calculator");

setSize(400,380);
setLocation(350,100);
setResizable(false);
setLayout(new BorderLayout());

setMenuBar();
setDisplay();
setButton();
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
setIcon();
mainPane.setLayout(new BorderLayout());
mainPane.setBackground(backgroundColor);
help=new HelpFrame();
about=new AboutFrame();

}

//==================================================================
//成员--方法域

//生成并设置图标
private void setIcon(){

int i,j,k,red,green,blue,h=63,w=63;
int[] pixels=new int[w*h];
for(k=i=0;i<h;i++)
for(j=0;j<w;j++){
red=(i*1^j*1)&0xff;
green=(i*2^j*2)&0xff;
blue=(i*4^j*4)&0xff;
pixels[k++]=0xff000000|(red<<16)|(green<<8)|blue;
}
icon=createImage(new MemoryImageSource(w,h,pixels,0,w));

setIconImage(icon);
}

//定义并设置菜单栏
private void setMenuBar(){

//定义菜单系统
JMenuBar
menuBar=new JMenuBar();

JMenu
fileMenu = new JMenu("File",true),
editMenu = new JMenu("Edit",true),
helpMenu = new JMenu("Help",true);

JMenuItem
openMenuItem = new JMenuItem("Open",'o'),
inMenuItem = new JMenuItem("Save input",'i'),
outMenuItem = new JMenuItem("Save outcome",'s'),
copyMenuItem = new JMenuItem("Copy",'c'),
pasteMenuItem = new JMenuItem("Paste",'p'),
clearMenuItem = new JMenuItem("Clear outcome",'r'),
helpMenuItem = new JMenuItem("Help contents",'h'),
changeMenuItme = new JMenuItem("Change UI",'u'),
aboutMenuItem = new JMenuItem("About T's Calculator",'a'),
popupMenuItem = new JMenuItem("About T's Calculator"),
copyMenuItem1 = new JMenuItem("Copy",'c'),
pasteMenuItem1 = new JMenuItem("Paste",'p');

//设置菜单系统
fileMenu.setMnemonic('F');
editMenu.setMnemonic('E');
helpMenu.setMnemonic('H');

openMenuItem. setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_O, InputEvent.CTRL_MASK));
inMenuItem. setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_I, InputEvent.CTRL_MASK));
outMenuItem. setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S, InputEvent.CTRL_MASK));
copyMenuItem. setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_C, InputEvent.CTRL_MASK));
pasteMenuItem. setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_V, InputEvent.CTRL_MASK));
clearMenuItem. setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_R, InputEvent.CTRL_MASK));
helpMenuItem. setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F1, 0));
aboutMenuItem. setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F2, 0));

//设置监听器

//这三个是对鼠标右键进行监听
mainPane.addMouseListener(this);
input.addMouseListener(this);
output.addMouseListener(this);

//下面主要是点击监听
openMenuItem.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent ae) {
filedialog.setMode(FileDialog.LOAD);
filedialog.setVisible(true);
File fi = new File(filedialog.getDirectory()+filedialog.getFile());
byte[] b = new byte[ (int) fi.length()];
try {
new FileInputStream(fi).read(b);
input.setText(new String(b,0,(int)fi.length()));
} catch (Exception e) {
e.printStackTrace();
}
}
});
inMenuItem.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent ae) {
filedialog.setMode(FileDialog.SAVE);
filedialog.setVisible(true);
if(filedialog.getDirectory()!=null&&filedialog.getFile()!=null){
String s=filedialog.getDirectory()+filedialog.getFile();
if(!s.endsWith(".txt"))s+=".txt";
File fi = new File(s);
try {
new FileOutputStream(fi).write(input.getText().getBytes());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
});
outMenuItem.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent ae) {
filedialog.setMode(FileDialog.SAVE);
filedialog.setVisible(true);
if(filedialog.getDirectory()!=null&&filedialog.getFile()!=null){
String s=filedialog.getDirectory()+filedialog.getFile();
if(!s.endsWith(".txt"))s+=".txt";
File fi = new File(s);
try {
new FileOutputStream(fi).write(output.getText().getBytes());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
});
copyMenuItem.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e) {
if(input. getSelectedText()!=null)input. copy(); else
if(output.getSelectedText()!=null)output.copy();
}
});
pasteMenuItem.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
input.paste();
}
});
clearMenuItem.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
output.setText("");
}
});
helpMenuItem.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e) {
help.setVisible(true);
}
});
changeMenuItme.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e) {
changeUI();
}
});
aboutMenuItem.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
about.setVisible(true);
}
});

copyMenuItem1.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e) {
if(input. getSelectedText()!=null)input. copy(); else
if(output.getSelectedText()!=null)output.copy();
}
});
pasteMenuItem1.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
input.paste();
}
});
popupMenuItem.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
about.setVisible(true);
}
});

//组合菜单系统
fileMenu.add(openMenuItem);
fileMenu.add(inMenuItem);
fileMenu.add(outMenuItem);

editMenu.add(copyMenuItem);
editMenu.add(pasteMenuItem);
editMenu.addSeparator();
editMenu.add(clearMenuItem);

helpMenu.add(helpMenuItem);
helpMenu.addSeparator();
helpMenu.add(changeMenuItme);
helpMenu.add(aboutMenuItem);

popupMenu.add(copyMenuItem1);
popupMenu.add(pasteMenuItem1);
popupMenu.addSeparator();
popupMenu.add(popupMenuItem);

menuBar.add(fileMenu);
menuBar.add(editMenu);
menuBar.add(helpMenu);

setJMenuBar(menuBar);
}

//设置显示区域
private void setDisplay(){

//定义
JPanel
TextPanel = new JPanel();

//设置
input.setFont(new Font(input.getFont().getFontName(),Font.PLAIN,15));
input.setText("");
output.setText("");
output.setEditable(false);
TextPanel.setLayout(new FlowLayout());
TextPanel.setBorder(new EmptyBorder(10,0,25,0));
TextPanel.setBackground( backgroundColor);
//设置光标监听器
input.addCaretListener(new CaretListener(){
public void caretUpdate(CaretEvent ce) {
caretDot=ce.getDot();
}
});

input.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent ae) {
getOutcome();
}
});

//组合
TextPanel.add(input);
TextPanel.add(outPane);
mainPane.add(TextPanel,BorderLayout.NORTH);
}

//设置按钮
private void setButton(){

//定义
JPanel
rootPanel = new JPanel(),
numPanel = new JPanel(),
funPanel = new JPanel();

Color
numColor = new Color(68,128,168),
funColor = new Color(38,68,138);

Insets
numInsets = new Insets(0,1,0,1),
funInsets = new Insets(0,1,0,1);

String[]
numLabels = {"7","8","9","Del","AC",
"4","5","6","×","÷",
"1","2","3","+","-",
"0",".","^","Ans","=",},
funLabels = {"sin","asin","sinh","(",")",
"cos","acos","cosh","ln","log",
"tan","atan","tanh","sqrt","1/x",
"cot","√","з√","x^2","x^3"};

JButton[]
numButtons=new JButton[numLabels.length],
funButtons=new JButton[funLabels.length];
for(int i=0;i<numLabels.length;i++)numButtons[i]=new JButton(numLabels[i]);
for(int i=0;i<funLabels.length;i++)funButtons[i]=new JButton(funLabels[i]);

//设置
rootPanel.setLayout(new BorderLayout());
rootPanel.setBorder(new EmptyBorder(15,15,15,15));
rootPanel.setBackground(backgroundColor);
numPanel.setBackground( backgroundColor);
funPanel.setBackground( backgroundColor);
numPanel.setLayout(new GridLayout(4,5,2,2));
funPanel.setLayout(new GridLayout(4,5,2,2));

for(JButton button:numButtons){
button.setForeground(numColor);
button.setMargin(numInsets);
button.addActionListener(this);
button.addMouseListener(this);
numPanel.add(button);
}

for(JButton button:funButtons){
button.setForeground(funColor);
button.setMargin(funInsets);
button.addActionListener(this);
button.addMouseListener(this);
funPanel.add(button);
}

//组合
rootPanel.add(numPanel,BorderLayout.EAST);
rootPanel.add(funPanel,BorderLayout.WEST);
mainPane.add(rootPanel,BorderLayout.CENTER);

}

//处理按键动作
public void actionPerformed(ActionEvent ae) {

String command=ae.getActionCommand();

if(command.equals("Del")) {
if(input.getSelectedText()==null&&0<caretDot){
input.setSelectionStart(caretDot-1);
input.setSelectionEnd(caretDot);
}
input.replaceSelection("");
} else
if(command.equals("AC")) {input.setText("");} else
if(command.equals("Ans")) {insert(answer);} else
if(command.equals("1/x")) {input.setText("1/("+input.getText()+")");} else
if(command.equals("x^2")) {insert("^2");} else
if(command.equals("x^3")) {insert("^3");} else
if(command.equals("=")) getOutcome(); else
insert(command);

}
//在input中插入字符串
private void insert(String ins){
if(input.getSelectedText()==null){
input.setSelectionStart(caretDot);
input.setSelectionEnd(caretDot);
}
input.replaceSelection(ins);
}

//计算输入字符串,并把结果添加在output中
private void getOutcome(){
try {
answer=calculator.calculate(input.getText());
} catch (Exception e) {
answer="0.0";
e.printStackTrace();
}
String appended="\r\n"+input.getText()+"\t= "+answer+" ";
output.append(appended);
output.setCaretPosition(output.getText().length());
}

private void changeUI(){

if(plaf instanceof WindowsLookAndFeel){
output.setColumns(33);
plaf = new MetalLookAndFeel();
}else{
output.setColumns(50);
plaf = new WindowsLookAndFeel();
}

try {
UIManager.setLookAndFeel(plaf);
} catch (UnsupportedLookAndFeelException e) {
e.printStackTrace();
}
SwingUtilities.updateComponentTreeUI(this);

}

@Override
public void mouseClicked(MouseEvent arg0) {
// TODO Auto-generated method stub

}

@Override
public void mouseEntered(MouseEvent arg0) {
// TODO Auto-generated method stub

}

@Override
public void mouseExited(MouseEvent arg0) {
// TODO Auto-generated method stub

}

@Override
public void mousePressed(MouseEvent arg0) {
// TODO Auto-generated method stub

}

//主要监听点击右键
public void mouseReleased(MouseEvent me) {
if(me.isPopupTrigger()) popupMenu.show(me.getComponent(),me.getX(),me.getY());
}

public static void main(String[] args) {
new CalculatorFrame01();
}

}

//=====================================================================================

while(true){
String str = sc.next(); //读控制台输入
if("#".equals(str)){
break;
}
// 判断是否操作数
if (str.matches("^(\\-?)(\\d+)(.\\d+)?$"))
stack.push(str);//把操作数或者操作符压入栈
// 如是
else if ("~".equals(str)) {
stack.push("-"+stack.pop());
}
else if("+".equals(str)){
double op2 = Double.parseDouble(stack.pop());
double op1 = Double.parseDouble(stack.pop());
stack.push(op1+op2+"");
}
else if("-".equals(str)){
double op2 = Double.parseDouble(stack.pop());
double op1 = Double.parseDouble(stack.pop());
stack.push(op1-op2+"");
}
else if("*".equals(str)){
double op2 = Double.parseDouble(stack.pop());
double op1 = Double.parseDouble(stack.pop());
stack.push(op1*op2+"");
}
else if("/".equals(str)){
double op2 = Double.parseDouble(stack.pop());
double op1 = Double.parseDouble(stack.pop());
stack.push(op1/op2+"");
}
else if("D".equalsIgnoreCase(str)){
stack.push(stack.peek());
}
}
String temp = stack.pop();
System.out.println(temp);
}
}

转载
import java.util.Scanner;
import java.util.Stack;

public class StackCal {
public static void main(String[] args){
System.out.println("请输入操作数或者操作符以空格分开 以#号表示输入结束");
Scanner sc = new Scanner(System.in);
Stack<String> stack = new Stack();

while(true){
String str = sc.next(); //读控制台输入
if("#".equals(str)){
break;
}
// 判断是否操作数
if (str.matches("^(\\-?)(\\d+)(.\\d+)?$"))
stack.push(str);//把操作数或者操作符压入栈
// 如是
else if ("~".equals(str)) {
stack.push("-"+stack.pop());
}
else if("+".equals(str)){
double op2 = Double.parseDouble(stack.pop());
double op1 = Double.parseDouble(stack.pop());
stack.push(op1+op2+"");
}
else if("-".equals(str)){
double op2 = Double.parseDouble(stack.pop());
double op1 = Double.parseDouble(stack.pop());
stack.push(op1-op2+"");
}
else if("*".equals(str)){
double op2 = Double.parseDouble(stack.pop());
double op1 = Double.parseDouble(stack.pop());
stack.push(op1*op2+"");
}
else if("/".equals(str)){
double op2 = Double.parseDouble(stack.pop());
double op1 = Double.parseDouble(stack.pop());
stack.push(op1/op2+"");
}
else if("D".equalsIgnoreCase(str)){
stack.push(stack.peek());
}
}
String temp = stack.pop();
System.out.println(temp);
}
}

TextField textfields = new TextField(27);
Dialog dlog=new Dialog(this,"about us");
Label aboutlab=new Label();
String s1;
String sedit;

Button buttons1 = new Button("Backspace");
int screenWidth,screenHeight;

Clipboard clp=Toolkit.getDefaultToolkit().getSystemClipboard();

---

美溪区17060662398： 用java语言,编写一个计算器 - ？
越胜十五： 有一个现成的.你看看吧import java.awt.event.ActionEvent;public class Application extends JFrame { protected String str = ＂＂;protected boolean isChar = true;protected boolean isEqual = false;protected JTextField textField; public ...

美溪区17060662398： 怎么用java写一个计算器 csdn - ？
越胜十五： 简单的的计时器代码: public static void main(String[] args) { System.out.println(＂请输入第一个数:＂); Scanner scanner1 = new Scanner(System.in); double input1 = Double.parseDouble(scanner1.nextLine());System.out.println(＂请输入...

美溪区17060662398： 用Java编写一个简单的计算器程序 - ？
越胜十五： import javax.swing.*; import java.awt.event.*; class Counter extends WindowAdapter { static JFrame f=new JFrame(＂计算器＂); static JTextField text1=new JTextField(＂0.＂); static String source=＂＂; static String cal=＂＂; static String ...

美溪区17060662398： JAVA编写计算器？
越胜十五： import java.awt.*; public class CalcTest { public static void main(String args[]) { Frame f=new Frame(＂计算器＂); Panel P=new Panel(); P.setLayout(new GridLayout(4,4,1,1)); P.setSize(200,200); TextField t=new TextField(); t.setBackground(...

美溪区17060662398： 如何用JAVA编写计算器?？
越胜十五： <html> <applet code=SZJSQ.class width=400 height=180> </applet> </html> //APPLET import java.util.*; import java.awt.*; import java.awt.event.*; import javax.swing.*; import java.applet.*; public class SZJSQ extends JApplet implements ...

美溪区17060662398： 如何用JAVA语言编写一个计算器?？
越胜十五： 关于界面我认为可以 利用netbeans拉出来.当然一个界面就行了.计算器关键是按钮功能,理解难点是如何将数字组合到一起.比如将1和2组合到一起行程12,在文本框里填写的数据,用gettext()方法提取之后,得到的是字符串.这个你必须事先知道.其次关键是提供一个临时变量,这个临时变量保存你再按符号之前的文本框的数据.再按符号后文本框内设置为空,在输入数字的时候,在调用方法提取现在的文本框里的内容,然后将原来提取的字符,与现在的字符加起来,构成字符集,在通过强制转换成double就行了＂1＂+＂2＂=＂12＂呵呵,就这么简单,你明白了吗

美溪区17060662398： java编写计算器! - ？
越胜十五： import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Calculator extends JFrame { private Container container; private GridBagLayout layout; private GridBagConstraints constraints; private JTextField displayField;//计算结果...

美溪区17060662398： 用java做一个计算器 - ？
越胜十五： public void jisuan(int a,int b,int c,int d,int e){ int result = ((a+b)*c-d)/e; System.out.println(result); }

美溪区17060662398： 用Java编写计算器 - ？
越胜十五： import java.util.regex.*; public class Calculation { public static void main(String[] args) throws Exception { // TODO Auto-generated method stub if (args.length != 3) { System.out.println(＂MyCal need 3 parameters the formate is:＂); System.out.println...

美溪区17060662398： 怎么用java编写计算器 - ？
越胜十五： 代码长分几段:(一个类哦.) import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Calculator extends JFrame { private Container container; private GridBagLayout layout; private GridBagConstraints constraints; private ...