【案例介绍】

1.案例描述

本案例要求利用Java Swing 图形组件开发一个可以进行简单的算术运算的图形化计算器。

2.运行结果

运行结果

【案例目标】

1. 学会分析“简易计算器”程序实现的逻辑思路。
2. 能够独立完成“简易计算器”程序的源代码编写、编译及运行。
3. 掌握Java Swing界面编程的应用。
4. 了解计算器逻辑运算实现。

【案例分析】

要制作一个计算器，首先要知道它由哪些部分组成，如下图所示：

一个简单的图形化界面计算器，需要由界面组件、组件的时间监听器和具体的事件处理逻辑组成。

实现一个简易图形化界面计算器可分以下几个步骤：

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 = new CalculatorTest();

二、图形化计算器界面及实现

1.UI组件创建和初始化：包括窗体的创建，显示计算结果文本框、清除按钮、数字按钮、运算符等按钮的初始化。组件的创建均在类CalculatorTest中定义声明为成员变量；组件的初始化、属性设置均在构造方法CalculatorTest( )中完成。

（1）在类CalculatorTest中定义声明为成员变量

1）创建窗体和初始化

// 创建一个 JFrame 对象并初始化。JFrame 可以理解为程序的主窗体。

JFrame frame = new JFrame("XXX的计算器");

2）创建文本框和初始化

//创建一个JTextField对象并初始化。显示 20 列的文本内容,result为运算结果，下面有定义，可以先隐藏这个参数，后面再显示

JTextField result_TextField = new JTextField(result, 20);

//属性设置：水平靠右

result_TextField.setHorizontalAlignment(JTextField.RIGHT);

3）创建各个按钮和初始化

//数字按钮、运算符等按钮

JButton btNum[],btOper[],btPoint,btEqual,btBack,btSqrt,btPingfang,btLifang,btYushu;

(2) 在构造方法CalculatorTest( )中初始化、设置相关属性

/*** 1 事件源   ***/

//数字按钮初始化：

//数字键0到9

btNum=new JButton[10];//数组对象

for(int i=0;i<=9;i++)

{

btNum[i]=new JButton(i+"");

}

// 设置数字0在当前模型上的键盘助记符

btNum[0].setMnemonic(KeyEvent.VK_0);

// 操作符按钮：

//计算的操作符命令按钮，加减乘除

btOper=new JButton[4];

btOper[0]=new JButton("+");

btOper[1]=new JButton("-");

btOper[2]=new JButton("*");

btOper[3]=new JButton("/");

//计算的特殊操作符命令按钮，平方根、平方、立方、求余

btSqrt=new JButton("Sqrt");

btPingfang=new JButton("^2");

btLifang=new JButton("^3");

btYushu=new JButton("%");

// 特殊按钮： （点 、等于、清空）

btPoint = new JButton(".");

btEqual = new JButton("=");

btBack=new JButton("Backspace");

2.在窗体中添加UI组件：包括放置数字键及运算符面板、放置清除框面板。

（1）在类CalculatorTest中定义声明为成员变量

JPanel pan1,pan2;

（2）在构造方法CalculatorTest( )中初始化、设置相关属性

1）在窗体中创建第一个面板pan1并设置布局

//设置第一个JPanel pan1

pan1 = new JPanel();

2）在第一个面板pan1中添加组件并设置布局

pan1.setLayout(new BorderLayout());

pan1.add(result_TextField, BorderLayout.WEST);

pan1.add(btBack, BorderLayout.EAST);

3）在窗体中创建第二个面板pan2并设置布局

// 创建第二个 Jpanel 对象并初始化

    pan2= new JPanel();

    // 设置该容器的布局为五行四列网格布局，边距为5像素

pan2.setLayout(new GridLayout(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(new BorderLayout());

frame.getContentPane().add(pan2, BorderLayout.NORTH);

frame.getContentPane().add(pan, BorderLayout.CENTER);

或者

frame.setLayout(new BorderLayout());

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 (Exception e) {

e.printStackTrace();

}

3.布局结束之后，就是计算器的难点：编写事件处理程序。

（1）在类CalculatorTest中声明定义如下成员变量（操作数1 、操作数2、运算符、运算结果、数字标志位、5个状态开关）

1）声明定义成员变量

// 操作数1，为了程序的安全，初值一定设置，这里我们设置为0。

    String str1 = "0";

   // 操作数2

String str2 = "0";

// 运算符

String oper = "+";

// 运算结果

String result = "";

//代表数字标志位

boolean isNum; 

// 以下k1至k5为状态开关

// 开关1用于选择输入方向，将要写入str1或str2

// 为 1 时写入 str1，为 2 时写入 str2

int k1 = 1;

// 开关 2 用于记录符号键的次数

// 如果 k2>1 说明进行的是 2+3-9+8 这样的多符号运算

int k2 = 1;

// 开关3用于标识 str1 是否可以被清 0

// 等于 1 时可以，不等于1时不能被清0

int k3 = 1;

// 开关4用于标识 str2 是否可以被清 0

// 等于 1 时可以，不等于1时不能被清0

int k4 = 1;

// 开关5用于控制小数点可否被录入

// 等于1时可以，不为1时，输入的小数点被丢掉

int k5 = 1;

// store的作用类似于寄存器，用于记录是否连续按下符号键

JButton store;

//vt 存储之前输入的运算符。

Vector vt = new Vector(20, 10);

2）包含构造函数

public CalculatorTest()

{ ……}

3）包含几个内部类

接收事件对象，激活事件处理器，实现预定功能。

class Listener_num implements ActionListener {

……

}

      //Listener_oper类中编写了运算符号键的响应逻辑

class Listener_oper implements ActionListener {

……

}

//Listener_backspace类中编写了清除键的响应逻辑

class Listener_backspace implements ActionListener {

……

}

//Listener_equal类中编写的是等于号键的响应逻辑

class Listener_equal implements ActionListener {

……

}

//Listener_point类中编写的是小数点键的相应逻辑

class Listener_point implements ActionListener

{

……

}

4）包含定义成员方法cal()

// calc()方法中编写了计算逻辑的实现。

public void cal()

{ …… }

4.按键的响应实现。

（1）在类CalculatorTest中声明定义如下内部类（监听器功能处理）：

1）数字键（0~9按钮）的响应

//Listener_num类中编写的是数字键的响应逻辑。

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 == 2) {

if (k4 == 1) {

str2 = "";

k5 = 1;

}

str2 = str2 + ss;

k4 = k4 + 1;

result_TextField.setText(str2);

}                              

}

}

2）运算符号键（操作符）的响应

      //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;

oper = 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("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类中编写了清除键的响应逻辑

class Listener_backspace implements ActionListener {

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";

oper = "";

result = "";

result_TextField.setText(result);

vt.clear();

}

}

4）等于号键的响应

//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;

}

}

5）小数点键的响应

//Listener_point类中编写的是小数点键的相应逻辑

class Listener_point implements ActionListener {

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;

}

}

5.计算逻辑的实现。

（1）在类CalculatorTest中声明定义成员方法cal( )，编写了计算逻辑的实现：

// calc()方法中编写了计算逻辑的实现。

public void cal()

{

double a2;

double b2;

String c = oper;

double result2 = 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 = 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);

}

}

6.注册监听器

(1) 在构造方法CalculatorTest( )中创建监听器并绑定事件

主要是事件处理机制中的监听器注册到事件源 、产生并传送事件对象和部分的处理功能。

1）窗体事件响应和注册监听

//窗体注册监听

        // 窗体关闭事件的响应程序

frame.addWindowListener(new WindowAdapter() {

public void windowClosing(WindowEvent e) {

System.exit(0);

}

});

2）数字按钮注册监听

//数字按钮注册监听

Listener_num jt_num = new Listener_num();

for(int i=0;i<=9;i++)

btNum[i].addActionListener(jt_num);

3）操作符按钮注册监听

//1 操作符按钮注册监听

//1.1 加减乘除操作符

Listener_oper jt_oper = new Listener_oper();

for(int j=0;j<=3;j++)

btOper[j].addActionListener(jt_oper);

//2 特殊操作符

//2.1 开根号按钮注册监听

Listener_oper jt_sqrt=new Listener_oper();

btSqrt.addActionListener(jt_sqrt);

//2.2 平方按钮注册监听

Listener_oper jt_pingfang=new Listener_oper();

btPingfang.addActionListener(jt_pingfang);

//2.3 立方按钮注册监听

Listener_oper jt_lifang=new Listener_oper();

btLifang.addActionListener(jt_lifang);

//2.4 百分号注册监听

Listener_oper jt_yushu=new Listener_oper();

btYushu.addActionListener(jt_yushu);

4）特殊按钮注册监听

//特殊按钮注册监听

          // 监听等于键

Listener_equal jt_equal = new Listener_equal();

         // 监听清除键

Listener_backspace jt_backspace = new Listener_backspace();

         // 监听小数点键

Listener_point jt_point = new Listener_point();

btEqual.addActionListener(jt_equal);

btBack.addActionListener(jt_backspace);

btPoint.addActionListener(jt_point);

具体步骤提示：

1. 定义了一些成员变量，方便响应的逻辑实现。
2. 创建了一个Vector对象，存储之前输入的运算符。
3. 创建了一个 JFrame 对象并初始化。JFrame 可以理解为程序的主窗体。
4. 创建了一个JTextField对象并初始化。JTextField用于显示操作和计算结果的文本框。参数 20 表明可以显示 20 列的文本内容。
5. 创建了一个清除按钮对象。
6. 创建数字键0-9按钮对象。
7. 创建计算命令按钮，加减乘除以及小数点等按钮对象。
8. 对计算器进行布局。
9. Listener_num类中编写的是数字键的响应逻辑。
10. Listener_point类中编写的是小数点键的相应逻辑。
11. Listener_oper类中编写了运算符号键的响应逻辑。
12. Listener_equal类中编写的是等于号键的响应逻辑。
13. Listener_backspace类中编写了清除键的响应逻辑。
14. calc()方法中编写了计算逻辑的实现。
15. 创建监听对象，并对各个按键进行监听。
16. 为窗体关闭事件的响应程序。
17. 通过 UIManager 来设置窗体的 UI 风格。

完整的代码：

package shixun;

import java.awt.BorderLayout;

import java.awt.GridLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.KeyEvent;

import java.awt.event.WindowAdapter;

import java.awt.event.WindowEvent;

import java.math.BigDecimal;

import java.util.Vector;

import javax.swing.BorderFactory;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JPanel;

import javax.swing.JTextField;

import javax.swing.SwingUtilities;

import javax.swing.UIManager;

class CalculatorTest {

JFrame f =new JFrame("xxx的简易计算器"); //创建一个 JFrame 对象并初始化。JFrame 可以理解为程序的主窗体。

JTextField result_TextField =new JTextField(20);   //创建一个JTextField对象并初始化。显示20列的文本内容，result为运算结果

JButton btNum[],btOper[],btPoint,btEqual,btBack,btSqrt,btPingfang,btLifang,btYushu; //创建各个按钮和初始化

JPanel pan1,pan2;   //声明定义成员变量  面板

//构造方法

public CalculatorTest(){

//数字按钮初始化 0-9

btNum=new JButton[10]; //数组对象

for(int i=0;i<=9;i++){

btNum[i]=new JButton(i+"");

}

btNum[0].setMnemonic(KeyEvent.VK_0);// 设置数字0在当前模型上的键盘助记符

//操作符按钮    计算的操作符命令按钮，加减乘除

btOper=new JButton[4];

btOper[0]=new JButton("+");

btOper[1]=new JButton("-");

btOper[2]=new JButton("*");

btOper[3]=new JButton("/");

//计算的特殊操作符命令按钮，开平方，平方根，立方根，求余

btSqrt=new JButton("Sqrt");

btPingfang=new JButton("^2");

btLifang=new JButton("^3");

btYushu=new JButton("%");

//特殊按钮 (点，等于，清空)

btPoint = new JButton(".");

btEqual = new JButton("=");

btBack = new JButton("Backspace");

//初始化  设置第一个JPanel

pan1 =new JPanel();

pan1.setLayout(new BorderLayout());   //设置布局

pan1.add(result_TextField,BorderLayout.WEST);

pan1.add(btBack,BorderLayout.EAST);

//创建第二个JPanel对象并初始化

pan2 =new JPanel();

pan2.setLayout(new GridLayout(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

   }

}

//关注公众号：《大学生生活与帮助》 了解更多与我相关