【案例介绍】
1**.**案例描述
本案例要求利用Java Swing 图形组件开发一个可以进行简单的算术运算的图形化计算器。
2**.**运行结果
运行结果
【案例目标】
【案例分析】
要制作一个计算器，首先要知道它由哪些部分组成，如下图所示：
一个简单的图形化界面计算器，需要由界面组件、组件的时间监听器和具体的事件处理逻辑组成。
实现一个简易图形化界面计算器可分以下几个步骤：
1.UI组件创建和初始化：包括窗体的创建，显示计算结果文本框、清除按钮、数字按钮、运算符等按钮的初始化。
2.在窗体中添加UI组件：包括放置数字键及运算符面板、放置清除框面板。
3.布局结束之后，就是计算器的难点：编写事件处理程序。
4.按键的响应实现。
5.计算逻辑的实现。
6.注册监听器
【实现步骤】
一、创建类Calculator.java
1. 创建类Calculator作为测试类；
1）创建主函数
2）通过 UIManager 来设置窗体的 UI 风格
2.创建类CalculatorTest
1）创建类CalculatorTest，并为类CalculatorTest添加无参的构造方法
public CalculatorTest()
{
……
}
2）主函数中声明计算器的对象cal
CalculatorTest cal= newCalculatorTest();
二、图形化计算器界面及实现
1.UI组件创建和初始化：包括窗体的创建，显示计算结果文本框、清除按钮、数字按钮、运算符等按钮的初始化。组件的创建均在类CalculatorTest中定义声明为成员变量；组件的初始化、属性设置均在构造方法CalculatorTest( )中完成。
（1）在类CalculatorTest中定义声明为成员变量
1）创建窗体和初始化
// 创建一个 JFrame 对象并初始化。JFrame 可以理解为程序的主窗体。
JFrame frame= newJFrame(“XXX的计算器”);
2）创建文本框和初始化
//创建一个JTextField对象并初始化。显示 20 列的文本内容,result为运算结果，下面有定义，可以先隐藏这个参数，后面再显示
JTextField result_TextField= newJTextField(result, 20);
//属性设置：水平靠右
result_TextField.setHorizontalAlignment(JTextField._RIGHT_);
3）创建各个按钮和初始化
//数字按钮、运算符等按钮
JButton btNum[],btOper[],btPoint,btEqual,btBack,btSqrt,btPingfang,btLifang,btYushu;
(2)在构造方法CalculatorTest( )中初始化、设置相关属性
/***1事件源 ***/
//数字按钮初始化：
//数字键0到9
btNum=newJButton[10];//数组对象
for(inti=0;i<=9;i++)
{
btNum[i]=newJButton(i+“”);
}
// 设置数字0在当前模型上的键盘助记符
btNum[0].setMnemonic(KeyEvent._VK_0_);
// 操作符按钮：
//计算的操作符命令按钮，加减乘除
btOper=newJButton[4];
btOper[0]=newJButton(“+”);
btOper[1]=newJButton(“-”);
btOper[2]=newJButton(“*”);
btOper[3]=newJButton(“/”);
//计算的特殊操作符命令按钮，平方根、平方、立方、求余
btSqrt=newJButton(“Sqrt”);
btPingfang=newJButton(“^2”);
btLifang=newJButton(“^3”);
btYushu=newJButton(“%”);
// 特殊按钮：（点 、等于、清空）
btPoint= newJButton(“.”);
btEqual= newJButton(“=”);
btBack=newJButton(“Backspace”);
2.在窗体中添加UI组件：包括放置数字键及运算符面板、放置清除框面板。
（1）在类CalculatorTest中定义声明为成员变量
JPanel pan1,pan2;
（2）在构造方法CalculatorTest( )中初始化、设置相关属性
1）在窗体中创建第一个面板pan1并设置布局
//设置第一个JPanel pan1
pan1= newJPanel();
2）在第一个面板pan1中添加组件并设置布局
pan1.setLayout(newBorderLayout());
pan1.add(result_TextField, BorderLayout._WEST_);
pan1.add(btBack, BorderLayout._EAST_);
3）在窗体中创建第二个面板pan2并设置布局
// 创建第二个 Jpanel对象并初始化
pan2= newJPanel();
// 设置该容器的布局为五行四列网格布局，边距为5像素
pan2.setLayout(newGridLayout(5, 4, 5, 5));
4）在第二个面板pan2中添加组件
// 将用于计算的按钮添加到容器内
pan2.add(btNum[7]);
pan2.add(btNum[8]);
pan2.add(btNum[9]);
pan2.add(btOper[3]);
pan2.add(btNum[4]);
pan2.add(btNum[5]);
pan2.add(btNum[6]);
pan2.add(btOper[2]);
pan2.add(btNum[1]);
pan2.add(btNum[2]);
pan2.add(btNum[3]);
pan2.add(btOper[1]);
pan2.add(btNum[0]);
pan2.add(btPoint);
pan2.add(btEqual);
pan2.add(btOper[0]);
pan2.add(btSqrt);
pan2.add(btPingfang);
pan2.add(btLifang);
pan2.add(btYushu);
// 设置 pan2 对象的边距
pan2.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
5）设置窗体frame的属性（窗口位置，窗口大小为可调）
// 设置主窗口出现在屏幕上的位置
frame.setLocation(300, 200);
// 设置窗体可以调大小
frame.setResizable(true);
6）将面板pan1和面板pan2加入窗体
//窗体中可以放置 JPanel，这里我们将面板pan1和面板pan2加入窗体
frame.getContentPane().setLayout(newBorderLayout());
frame.getContentPane().add(pan2, BorderLayout._NORTH_);
frame.getContentPane().add(pan, BorderLayout._CENTER_);
或者
frame.setLayout(newBorderLayout());
frame.add(pan1, BorderLayout._NORTH_);
frame.add(pan2, BorderLayout._CENTER_);
7）设置窗体frame的属性（窗口大小匹配、窗口可见等）
frame.pack();//根据UI组件内容决定窗口大小
frame.setVisible(true);//设置窗口可见
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
8）主函数中设置窗体的 UI 风格
try{
//通过 UIManager 来设置窗体的 UI 风格
UIManager.setLookAndFeel(“javax.swing.plaf.metal.MetalLookAndFeel”);
} catch(Exceptione) {
e.printStackTrace();
}
3.布局结束之后，就是计算器的难点：编写事件处理程序。
（1）在类CalculatorTest中声明定义如下成员变量（操作数1 、操作数2、运算符、运算结果、数字标志位、5个状态开关）
1）声明定义成员变量
// 操作数1，为了程序的安全，初值一定设置，这里我们设置为0。
String str1= “0”;
// 操作数2
String str2= “0”;
// 运算符
String oper= “+”;
// 运算结果
String result= “”;
//代表数字标志位
booleanisNum;
// 以下k1至k5为状态开关
// 开关1用于选择输入方向，将要写入str1或str2
// 为 1 时写入 str1，为 2 时写入 str2
intk1= 1;
// 开关 2 用于记录符号键的次数
// 如果 k2>1 说明进行的是 2+3-9+8 这样的多符号运算
intk2= 1;
// 开关3用于标识 str1 是否可以被清 0
// 等于 1 时可以，不等于1时不能被清0
intk3= 1;
// 开关4用于标识 str2 是否可以被清 0
// 等于 1 时可以，不等于1时不能被清0
intk4= 1;
// 开关5用于控制小数点可否被录入
// 等于1时可以，不为1时，输入的小数点被丢掉
intk5= 1;
// store的作用类似于寄存器，用于记录是否连续按下符号键
JButton store;
//vt存储之前输入的运算符。
Vector vt= newVector(20, 10);
2）包含构造函数
publicCalculatorTest()
{ ……}
3）包含几个内部类
接收事件对象，激活事件处理器，实现预定功能。
classListener_num implementsActionListener {
……
}
//Listener_oper类中编写了运算符号键的响应逻辑
classListener_oper implementsActionListener {
……
}
//Listener_backspace类中编写了清除键的响应逻辑
classListener_backspace implementsActionListener {
……
}
//Listener_equal类中编写的是等于号键的响应逻辑
classListener_equal implementsActionListener {
……
}
//Listener_point类中编写的是小数点键的相应逻辑
classListener_point implementsActionListener
{
……
}
4）包含定义成员方法cal()
// calc()方法中编写了计算逻辑的实现。
public********voidcal()
{ …… }
4.按键的响应实现。
（1）在类CalculatorTest中声明定义如下内部类（监听器功能处理）：
1）数字键（0~9按钮）的响应
//Listener_num类中编写的是数字键的响应逻辑。
classListener_numimplementsActionListener {
public********voidactionPerformed(ActionEvent e) {
String ss= ((JButton) e.getSource()).getText();
store= (JButton) e.getSource();
vt.add(store);
if(k1== 1) {
if(k3== 1) {
str1= “”;
k5= 1;
}
str1= str1+ ss;
k3= k3+ 1;
result_TextField.setText(str1);
} else********if(k1== 2) {
if(k4== 1) {
str2= “”;
k5= 1;
}
str2= str2+ ss;
k4= k4+ 1;
result_TextField.setText(str2);
}
}
}
2）运算符号键（操作符）的响应
//Listener_oper类中编写了运算符号键的响应逻辑
classListener_oper implementsActionListener {
public********voidactionPerformed(ActionEvent e) {
String ss2= ((JButton) e.getSource()).getText();
store= (JButton) e.getSource();
vt.add(store);
if(k2== 1) {
k1= 2;
k5= 1;
oper= ss2;
k2= k2+ 1;
} else{
inta= vt.size();
JButton c= (JButton) vt.get(a- 2);
if(!(c.getText().equals(“+”))
&& !(c.getText().equals(“-”))
&& !(c.getText().equals(“*”))
&& !(c.getText().equals(“/”))
&& !(c.getText().equals(“Sqrt”))&& !(c.getText().equals(“^2”))
&& !(c.getText().equals(“^3”))&& !(c.getText().equals(“%”)))
{
cal();
str1= result;
k1= 2;
k5= 1;
k4= 1;
oper= ss2;
}
k2= k2+ 1;
}
}
}
3）清除键的响应
//Listener_backspace类中编写了清除键的响应逻辑
classListener_backspace implementsActionListener {
public********voidactionPerformed(ActionEvent e) {
store= (JButton) e.getSource();
vt.add(store);
k5= 1;
k2= 1;
k1= 1;
k3= 1;
k4= 1;
str1= “0”;
str2= “0”;
oper= “”;
result= “”;
result_TextField.setText(result);
vt.clear();
}
}
4）等于号键的响应
//Listener_equal类中编写的是等于号键的响应逻辑
classListener_equal implementsActionListener {
public********voidactionPerformed(ActionEvent e) {
store= (JButton) e.getSource();
vt.add(store);
cal();
k1= 1;
k2= 1;
k3= 1;
k4= 1;
str1= result;
}
}
5）小数点键的响应
//Listener_point类中编写的是小数点键的相应逻辑
classListener_point implementsActionListener {
public********voidactionPerformed(ActionEvent e) {
store= (JButton) e.getSource();
vt.add(store);
if(k5== 1) {
String ss2= ((JButton) e.getSource()).getText();
if(k1== 1) {
if(k3== 1) {
str1= “”;
k5= 1;
}
str1= str1+ ss2;
k3= k3+ 1;
result_TextField.setText(str1);
} else********if(k1== 2) {
if(k4== 1) {
str2= “”;
k5= 1;
}
str2= str2+ ss2;
k4= k4+ 1;
result_TextField.setText(str2);
}
}
k5= k5+ 1;
}
}
5.计算逻辑的实现。
（1）在类CalculatorTest中声明定义成员方法cal( )，编写了计算逻辑的实现：
// calc()方法中编写了计算逻辑的实现。
public********voidcal()
{
doublea2;
doubleb2;
String c= oper;
doubleresult2= 0;
if(c.equals(“”)) {
result_TextField.setText(“Please input operator”);
} else{
if(str1.equals(“.”))
str1= “0.0”;
if(str2.equals(“.”))
str2= “0.0”;
a2= Double.valueOf(str1).doubleValue();
b2= Double.valueOf(str2).doubleValue();
if(c.equals(“+”)) {
result2= a2+ b2;
}
if(c.equals(“-”)) {
result2= a2- b2;
}
if(c.equals(“*”)) {
BigDecimal m1= newBigDecimal(Double.toString(a2));
BigDecimal m2= new
BigDecimal(Double.toString(b2));
result2= m1.multiply(m2).doubleValue();
}
if(c.equals(“/”)) {
if(b2== 0) {
result2= 0;
} else{
result2= a2/ b2;
}
}
if(c.equals(“Sqrt”)) {
result2= Math.sqrt(a2);
}
if(c.equals(“^2”)) {
result2= a2*a2;
}
if(c.equals(“^3”)) {
result2= a2*a2*a2;
}
if(c.equals(“%”)) {
if(b2== 0) {
result2= 0;
} else{
result2= a2% b2;
}
}
result= ((newDouble(result2)).toString());
result_TextField.setText(result);
}
}
6.注册监听器
(1)在构造方法CalculatorTest( )中创建监听器并绑定事件
主要是事件处理机制中的监听器注册到事件源 、产生并传送事件对象和部分的处理功能。
1）窗体事件响应和注册监听
//窗体注册监听
// 窗体关闭事件的响应程序
frame.addWindowListener(newWindowAdapter() {
public********voidwindowClosing(WindowEvent e) {
System.exit(0);
}
});
2）数字按钮注册监听
//数字按钮注册监听
Listener_num jt_num= newListener_num();
for(inti=0;i<=9;i++)
btNum[i].addActionListener(jt_num);
3）操作符按钮注册监听
//1操作符按钮注册监听
//1.1加减乘除操作符
Listener_oper jt_oper= newListener_oper();
for(intj=0;j<=3;j++)
btOper[j].addActionListener(jt_oper);
//2特殊操作符
//2.1 开根号按钮注册监听
Listener_oper jt_sqrt=newListener_oper();
btSqrt.addActionListener(jt_sqrt);
//2.2 平方按钮注册监听
Listener_oper jt_pingfang=newListener_oper();
btPingfang.addActionListener(jt_pingfang);
//2.3 立方按钮注册监听
Listener_oper jt_lifang=newListener_oper();
btLifang.addActionListener(jt_lifang);
//2.4 百分号注册监听
Listener_oper jt_yushu=newListener_oper();
btYushu.addActionListener(jt_yushu);
4）特殊按钮注册监听
//特殊按钮注册监听
// 监听等于键
Listener_equal jt_equal= newListener_equal();
// 监听清除键
Listener_backspace jt_backspace= newListener_backspace();
// 监听小数点键
Listener_point jt_point= newListener_point();
btEqual.addActionListener(jt_equal);
btBack.addActionListener(jt_backspace);
btPoint.addActionListener(jt_point);
具体步骤提示：
完整的代码：
packageshixun;
importjava.awt.BorderLayout;
importjava.awt.GridLayout;
importjava.awt.event.ActionEvent;
importjava.awt.event.ActionListener;
importjava.awt.event.KeyEvent;
importjava.awt.event.WindowAdapter;
importjava.awt.event.WindowEvent;
importjava.math.BigDecimal;
importjava.util.Vector;
importjavax.swing.BorderFactory;
importjavax.swing.JButton;
importjavax.swing.JFrame;
importjavax.swing.JPanel;
importjavax.swing.JTextField;
importjavax.swing.SwingUtilities;
importjavax.swing.UIManager;
classCalculatorTest {
JFrame f =newJFrame(“xxx的简易计算器”); //创建一个 JFrame 对象并初始化。JFrame 可以理解为程序的主窗体。
JTextField result_TextField =newJTextField(20); //创建一个JTextField对象并初始化。显示20列的文本内容，result为运算结果
JButton btNum[],btOper[],btPoint,btEqual,btBack,btSqrt,btPingfang,btLifang,btYushu; //创建各个按钮和初始化
JPanel pan1,pan2; //声明定义成员变量 面板
//构造方法
public********CalculatorTest(){
//数字按钮初始化 0-9
btNum=newJButton[10]; //数组对象
for(int********i=0;i<=9;i++){
btNum[i]=newJButton(i+“”);
}
btNum[0].setMnemonic(KeyEvent._VK_0_);// 设置数字0在当前模型上的键盘助记符
//操作符按钮 计算的操作符命令按钮，加减乘除
btOper=newJButton[4];
btOper[0]=newJButton(“+”);
btOper[1]=newJButton(“-”);
btOper[2]=newJButton(“*”);
btOper[3]=newJButton(“/”);
//计算的特殊操作符命令按钮，开平方，平方根，立方根，求余
btSqrt=newJButton(“Sqrt”);
btPingfang=newJButton(“^2”);
btLifang=newJButton(“^3”);
btYushu=newJButton(“%”);
//特殊按钮 (点，等于，清空)
btPoint = newJButton(“.”);
btEqual = newJButton(“=”);
btBack = newJButton(“Backspace”);
//初始化 设置第一个JPanel
pan1 =newJPanel();
pan1.setLayout(newBorderLayout()); //设置布局
pan1.add(result_TextField,BorderLayout._WEST_);
pan1.add(btBack,BorderLayout._EAST_);
//创建第二个JPanel对象并初始化
pan2 =newJPanel();
pan2.setLayout(newGridLayout(5, 4, 5, 5)); // 网格布局管理器 五行四列网格布局，边距为5像素
//将用于计算的按钮添加到容器内
pan2.add(btNum[7]);
pan2.add(btNum[8]);
pan2.add(btNum[9]);
pan2.add(btOper[3]);
pan2.add(btNum[4]);
pan2.add(btNum[5]);
pan2.add(btNum[6]);
pan2.add(btOper[2]);
pan2.add(btNum[1]);
pan2.add(btNum[2]);
pan2.add(btNum[3]);
pan2.add(btOper[1]);
pan2.add(btNum[0]);
pan2.add(btPoint);
pan2.add(btEqual);
pan2.add(btOper[0]);
pan2.add(btSqrt);
pan2.add(btPingfang);
pan2.add(btLifang);
pan2.add(btYushu);
//设置Pan2的边距
pan2.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
//设置主窗口属性
//f.setLayout(new GridLayout(3,3));
f.pack(); //根据UI组件内容决定窗口大小
f.setSize(350,300); //主窗口大小
f.setResizable(true); //主窗口可调大小
f.setLocation(300,200); //主窗口在屏幕上的位置
f.setVisible(true); //设置窗口可见
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//窗体中可以放置JPanel，这里我们将面板pan1和pan2加入窗体
f.getContentPane().setLayout(new BorderLayout());
f.getContentPane().add(pan1,BorderLayout.NORTH);
f.getContentPane().add(pan2,BorderLayout.CENTER);
result_TextField.setHorizontalAlignment(JTextField.RIGHT);// TestField属性设置：水平靠右
//注册各个监听器，即绑定事件响应逻辑到各个UI组件上
//数字按钮注册监听 btPoint = new JButton(“.”);
Listener_num jt_num =new Listener_num();
for(int i=0;i<=9;i++)
btNum[i].addActionListener(jt_num);
//操作符按钮注册监听 + - * /
Listener_oper jt_oper =new Listener_oper();
for(int j=0;j<=3;j++)
btOper[j].addActionListener(jt_oper);
//特殊操作符 根号 ^2 ^3 %
Listener_oper jt_sqrt =new Listener_oper();
btSqrt.addActionListener(jt_sqrt);
Listener_oper jt_pingfang =new Listener_oper();
btPingfang.addActionListener(jt_pingfang);
Listener_oper jt_Lifang =new Listener_oper();
btLifang.addActionListener(jt_Lifang);
Listener_oper jt_Yushu =new Listener_oper();
btYushu.addActionListener(jt_Yushu);
//特殊按钮注册监听 = 清空 .
Listener_equal jt_equal=new Listener_equal();
btEqual.addActionListener(jt_equal);
Listener_backspace jt_backspace=new Listener_backspace();
btBack .addActionListener(jt_backspace);
Listener_point jt_point=new Listener_point();
btPoint.addActionListener(jt_point);
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e){
System.exit(0);}
});
}
//声明定义成员变量,操作数1和2，为了程序安全，初值一定设置，这里我们设置为0.
String str1=“0”;
String str2=“0”;
String signal=“+”;//运算符
String result=“=”;//运算结果
//以下为k1-k5为状态开关，分别表示选择输入方向、记录符号键的次数、用于标识 str1 是否可以被清 0、用于标识 str2 是否可以被清 0、用于控制小数点可否被录入
int k1=1; // 用于选择输入方向，将要写入str1或str2
int k2=1; //用于记录符号键的次数，如果k2>1说明进行是2+3-9+5这样的多符号运算
int k3=1; //用于标识 str1 是否可以被清 0,等于1时可以，不等于1时不能被清0
int k4=1; //用于标识 str2 是否可以被清 0,等于1时可以，不等于1时不能被清0
int k5=1; //用于控制小数点可否被录入,等于1时可以,不为1时,输入的小数点会被丢掉
//store的作用类似于寄存器，用于记录是否连续按下符号键
JButton store;
@SuppressWarnings(“rawtypes”)
Vector vt =new Vector(20,10);//vt 存储之前输入的运算符。
//内部类 接收事件对象，激活事件处理器，实现预定功能。
//数字键
class Listener_num implements ActionListener {
public void actionPerformed(ActionEvent e){
String ss=((JButton) e.getSource()).getText();
store = (JButton) e.getSource();
vt.add(store);
if (k1 == 1) {
if (k3 == 1){
str1=“”;
k5=1;
}
str1=str1+ss;
k3=k3+1;
result_TextField.setText(str1);
}else if (k1 == k2){
if (k4 == 1){
str2 = “”;
k5=1;
}
str2=str2+ss;
k4=k4+1;
result_TextField.setText(str2);
}
}
}
//Listener_oper类中编写了运算符号键的响应逻辑
class Listener_oper implements ActionListener {
public void actionPerformed(ActionEvent e){
String ss2=((JButton) e.getSource()).getText();
store=(JButton) e.getSource();
vt.add(store);
if(k2==1){
k1=2;
k5=1;
signal = ss2;
k2=k2+1;
}else {
int a=vt.size();
JButton c=(JButton) vt.get(a-2);
if (!(c.getText().equals(“+”)) && !(c.getText().equals(“-”)) && !(c.getText().equals(“*”)) && !(c.getText().equals(“/”)) && !(c.getText().equals(“Sqart”)) && !(c.getText().equals(“^2”)) && !(c.getText().equals(“^3”)) && !(c.getText().equals(“%”))){
cal();
str1=result;
k1=2;
k5=1;
k4=1;
signal=ss2;
}
k2=k2+1;
}
}
}
//Listener_backspace类中编写了清除键的响应逻辑
class Listener_backspace implements ActionListener {
@SuppressWarnings(“unchecked”)
public void actionPerformed(ActionEvent e){
store=(JButton) e.getSource();
vt.add(store);
k5=1;
k2=1;
k1=1;
k3=1;
k4=1;
str1=“0”;
str2=“0”;
signal=“”;
result=“”;
result_TextField.setText(result);
vt.clear();
}
}
//Listener_equal类中编写的是等于号键的响应逻辑
class Listener_equal implements ActionListener {
public void actionPerformed(ActionEvent e){
store=(JButton) e.getSource();
vt.add(store);
cal();
k1=1;
k2=1;
k3=1;
k4=1;
str1=result;
}
}
//Listener_point类中编写的是小数点键的相应逻辑
class Listener_point implements ActionListener {
@SuppressWarnings(“unchecked”)
public void actionPerformed(ActionEvent e){
store=(JButton) e.getSource();
vt.add(store);
if(k5==1){
String ss2=((JButton) e.getSource()).getText();
if(k1==1){
if(k3==1){
str1=“”;
k5=1;
}
str1=str1+ss2;
k3=k3+1;
result_TextField.setText(str1);
}else if(k1==2){
if(k4==1){
str2=“”;
k5=1;
}
str2=str2+ss2;
k4=k4+1;
result_TextField.setText(str2);
}
}k5=k5+1；
}
}
}
// cal()方法中编写了计算逻辑的实现
public void cal(){
double a2;
double b2;
String c=signal;
double result2 = 0;
if (c.equals(“”)) {
result_TextField.setText(“Please input operator”);
}else {
if (c.equals(“.”))
str1=“0.0”;
if (c.equals(“.”))
str2=“0.0”;
a2=Double.valueOf(str1).doubleValue();
b2=Double.valueOf(str2).doubleValue();
if (c.equals(“+”))
result2=a2+b2;
if (c.equals(“-”))
result2=a2-b2;
if (c.equals(“*”)){
BigDecimal m1=new BigDecimal(Double.toString(a2));
BigDecimal m2=new BigDecimal(Double.toString(b2));
result2=m1.multiply(m2).doubleValue();
}
if (c.equals(“/”)){
if(b2==0){
result2=0;
}else {
result2=a2/b2;
}
}
if (c.equals(“Sqrt”)){
result2=Math.sqrt(a2);
}
if (c.equals(“^2”)){
result2=a2*a2;
}
if (c.equals(“^3”)){
result2=a2*a2*a2;
}
if (c.equals(“%”)){
if(b2==0){
result2=0;
}else {
result2=a2%b2;
}
}
result=((new Double(result2)).toString());
result_TextField.setText(result);
}
}
}
public class Calculator {
public static void main(String[] args) {
try { //通过 UIManager 来设置窗体的 UI 风格
UIManager.setLookAndFeel(“javax.swing.plaf.metal.MetalLookAndFeel”);
} catch (Exception e) {
e.printStackTrace();
}
CalculatorTest cal = new CalculatorTest(); //主函数中声明计算器的对象cal
}
}