Java版图形界面计算器

本文主要是介绍Java版图形界面计算器，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

Java版图形界面计算器

文章目录

• • Java版图形界面计算器
  • • 项目创建
    • UI 组件创建和初始化
    • • （1）窗口的创建
      • （2）所需的组件
    • 在窗体中添加 UI 组件
    • • （1）面板
      • （2）放置数字键等的面板
      • （3）放置清除框等的面板
      • （4）窗体添加面板 1 和面板 2
    • 响应事件需要使用的变量
    • 数字键的响应
    • 小数点的响应
    • 运算符号的响应
    • 等于的响应
    • 计算逻辑的实现
    • 清除的响应
    • 注册监听器

项目创建

（1）在文件菜单 File 中选择 New -> Project 来创建项目。

（2）在弹出的新建项目对话框中选择 Java Project，并点击 Next 按钮进入下一步。

（3）在 Project name 一栏填写项目名称 Calculator，并点击 Finish 按钮完成创建。

（4）如果遇到下图所示的对话框，点击 Open Perspective 按钮确认即可。

（5）在创建好后的项目目录 src 上右键点击，在右键菜单中选择 New -> Class 来创建一个类。

（6）在新建类对话框中填写包名 com.shiyanlou.calculator 和类名 Calculator （首字母大写）。点击 Finish 按钮完成创建。

UI 组件创建和初始化

首先我们需要将界面中要用到的 UI 组件作为 Calculator 类的成员变量在一开始声明。在阅读代码之前，可以思考一下都要用到哪些 UI 组件，以及这些代码应当写在哪个位置等等。

一个计算器界面至少包括窗口、按钮和显示文本框。如下图，这是我们希望达到的效果。

（1）窗口的创建

创建一个窗口需要使用 JFrame 类。在本实验中，我们创建一个 JFrame 实例，并调用实例的方法进行组件的添加（与之前编写一个 JFrmae 子类的效果是相同的）。

// 创建一个 JFrame 对象并初始化。JFrame 可以理解为程序的主窗体。
JFrame frame = new JFrame("Calculator");

// 设置主窗口出现在屏幕上的位置
frame.setLocation(300, 200);

// 设置窗体不能调大小
frame.setResizable(false);

这里，我们先不设置窗口的大小，待我们将所有组件添加到窗体上之后，调用 pack() 方法，让窗体自己调整大小（在 3.3 （4）窗体添加面板 1 和面板 2 部分会介绍）。

（2）所需的组件

• 显示计算结果

// 创建一个 JTextField 对象并初始化。 JTextField 是用于显示操作和计算结果的文本框。
// 参数 20 表明可以显示 20 列的文本内容
JTextField result_TextField = new JTextField(result, 20);

这里的 result 是等会儿会创建的一个 String 对象，它记录了计算的结果，我们赋予其初始值 ""（空字符串）。

• 清除按钮

// 清除按钮
JButton clear_Button = new JButton("Clear");

• 数字按钮

// 数字键0到9
JButton button0 = new JButton("0");
JButton button1 = new JButton("1");
JButton button2 = new JButton("2");
JButton button3 = new JButton("3");
JButton button4 = new JButton("4");
JButton button5 = new JButton("5");
JButton button6 = new JButton("6");
JButton button7 = new JButton("7");
JButton button8 = new JButton("8");
JButton button9 = new JButton("9");

• 操作符按钮

// 计算命令按钮，加减乘除以及小数点等
JButton button_Dian = new JButton(".");
JButton button_jia = new JButton("+");
JButton button_jian = new JButton("-");
JButton button_cheng = new JButton("*");
JButton button_chu = new JButton("/");

• 等于按钮（按下后进行计算）

// 计算按钮
JButton button_dy = new JButton("=");

在窗体中添加 UI 组件

（1）面板

这个计算器有两个 JPanel。

什么是 JPanel：JPanel 是一般轻量级容器。如上图所示，你可以将其理解为一个盛放其他 UI 组件的“篮子”。 JPanel 位于 javax.swing 包中，为面板容器，可以加入到 JFrame 中 ， 它自身是个容器，也可以把其他 component （组件） 加入到 JPanel 中，例如 JButton、JTextArea、JTextField 等。

在这个项目中，两个 JPanel 分别对应这个计算器按键除 “Clear” 键外其他的键，另外一个面板则是输出栏跟 “Clear” 键，参考如下图。

同样，在书写本段代码时，你应当思考它应该放在哪个部分。如果不清楚，可以回到上面的代码结构中查看。

（2）放置数字键等的面板

对于面板 1，可供参考的代码如下所示：

首先初始化一个面板对象 pan。

// 创建一个 Jpanel 对象并初始化
JPanel pan = new JPanel();

设置 pan 的布局为网格布局 GridLayout，具体的使用方法可以参考 Class GridLayout - 官方文档。在本程序中，我们使用的 GridLayout 构造函数传入了四个参数，含义分别为创建一个 4 行（第一个参数）、4 列（第二个参数）的网格，每个网格宽度为 5（第三个参数）、高度为 5 （第四个参数）。

// 设置该容器的布局为四行四列，边距为5像素
pan.setLayout(new GridLayout(4, 4, 5, 5));

如下图，但我们对 pan 进行 add 操作时，组件会按照 1、2、3… 的顺序进行填充。

对比之前的效果图，我们应该按照下面的顺序进行 add 操作。

// 将用于计算的按钮添加到容器内
pan.add(button7);
pan.add(button8);
pan.add(button9);
pan.add(button_chu);
pan.add(button4);
pan.add(button5);
pan.add(button6);
pan.add(button_cheng);
pan.add(button1);
pan.add(button2);
pan.add(button3);
pan.add(button_jian);
pan.add(button0);
pan.add(button_Dian);
pan.add(button_dy);
pan.add(button_jia);

为了更加好看，我们可以为 pan 对象设置边距。

// 设置 pan 对象的边距
pan.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));

（3）放置清除框等的面板

对于面板 2，可供参考的代码如下：

首先初始化一个面板对象 pan2。

// 按照同样的方式设置第二个JPanel
JPanel pan2 = new JPanel();

设置它的布局为边界布局。边界布局管理器把容器的的布局分为五个位置：CENTER、EAST、WEST、NORTH、SOUTH。依次对应为：上北（NORTH）、下南（SOUTH）、左西（WEST）、右东（EAST），中（CENTER）。如下图所示：

pan2.setLayout(new BorderLayout());
pan2.add(result_TextField, BorderLayout.WEST);
pan2.add(clear_Button, BorderLayout.EAST);

这里我们只设置了 WEST 和 EAST，其他部分没有添加任何东西（没有添加的部分相当于空白）。

（4）窗体添加面板 1 和面板 2

窗体中可以放置 JPanel，这里是指我们刚刚创建的面板 1 和面板 2，添加的代码如下：

frame.getContentPane().setLayout(new BorderLayout());
frame.getContentPane().add(pan2, BorderLayout.NORTH);
frame.getContentPane().add(pan, BorderLayout.CENTER);

这里，对于 frame.getContentPane()（它返回 JFrame 中默认的 JPanel），我们设置布局为 BorderLayout。

当我们添加窗体之后

frame.pack();
frame.setVisible(true);

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

响应事件需要使用的变量

对于计算器而言，涉及到的事件响应逻辑主要有：数字键、加减乘除运算、小数点处理、等于以及清除。

这里，我们定义了一些成员变量，方便响应的逻辑实现。

首先，需要定义存储当前被按下的操作数和操作符，result 存储运算的结果。

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

// 操作数2
String str2 = "0";

// 运算符
String signal = "+";

// 运算结果
String result = "";

接下来，我们还定义了五个状态开关（五个 int 变量），其含义在注释中有说明。

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

这里我们额外定义了一个 JButton 变量，用于存储被按下的符号键。

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

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

@SuppressWarnings("rawtypes")
Vector vt = new Vector(20, 10);

数字键的响应

注意，我们后面所有定义的 ActionListener 都写在构造函数中，即定义为局部内部类。

数字键响应的主要是处理数字存入到对应的变量中（第一个操作数存入 str1，第二个操作数存入 str2）。

这里我们定义的局部内部类名为 Listener，继承 ActionListener 接口。继承之后，我们需要重写接口定义的 actionPerformed 方法。

class Listener implements ActionListener {
    @Override
    public void actionPerformed(ActionEvent e) {

    }
}

通过上面的 actionPerformed 方法 的入参 ActionEvent e，我们可以获取到事件源，如下：

// 获取事件源，并从事件源中获取输入的数据
String ss = ((JButton) e.getSource()).getText();

接下来读入存储的符号键，并添加到 vt 中去。

// 读入存储的符号键
store = (JButton) e.getSource();
vt.add(store);

还记得我们之前定义的 k1 开关吗？当 k1 为 1 时，我们输入的数字是操作数 1 的一部分；当 k1 为 2 时，我们输入的数字是操作数 2 的一部分。因此会有以下逻辑：

if( k1 == 1) {
    // 输入是操作数 1 的一部分
} else if( k1 == 2) {
    // 输入是操作数 2 的一部分
}

• 输入为操作数 1 的一部分时

我们需要判断操作数 1 是否可以被清零（通过 k3 的值即可判断），如果可以（存储的内容是上一次运算的），则先清空再写入；如果不可以清零（先前已经输入了操作数 1 的一部分，比如输入数字 34，上一次按了 3，这一次读到的是 4），这种情况下需要将输入追加到上一次的输入中

if (k3 == 1) {
    str1 = "";

    // 还原开关k5状态
    k5 = 1;
}
str1 = str1 + ss;

这里，我们输入的是数字，因此后面随时可用输入小数点，为了防止出错，给 k5 进行赋值。

当输入完成后，我们需要给 k3 的值加 1，保证 操作数 1 不会被清空。并且还需要将操作数 1 打印到结果栏。

k3 = k3 + 1;

// 显示结果
result_TextField.setText(str1);

• 输入为操作数 2 的一部分时

这部分的逻辑与操作数 1 是完全相同的。唯一不同的是，操作数变为了 str2（即操作数 2）。

if (k4 == 1) {
    str2 = "";

    // 还原开关k5状态
    k5 = 1;
}
str2 = str2 + ss;
k4 = k4 + 1;
result_TextField.setText(str2);

完整的代码如下：

// 数字键
class Listener implements ActionListener {
    @SuppressWarnings("unchecked")
    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状态
                k5 = 1;
            }
            str1 = str1 + ss;

            k3 = k3 + 1;

            // 显示结果
            result_TextField.setText(str1);

        } else if (k1 == 2) {
            if (k4 == 1) {
                str2 = "";

                // 还原开关k5状态
                k5 = 1;
            }
            str2 = str2 + ss;
            k4 = k4 + 1;
            result_TextField.setText(str2);
        }

    }
}

小数点的响应

注意，小数点的响应也是定义为局部内部类，与数字键的响应类是相同的。这个局部内部类命令为 Listener_xiaos，继承 ActionListener 接口。

首先是获取响应源，并添加到 vt 中。

store = (JButton) e.getSource();
vt.add(store);

输入小数点需要在 k5 为 1 的情况下才可以输入，否则输入的小数点被丢掉。

if( k5 == 1) {
    // 添加对小数点的处理
}

接下来，我们写上面的 if 语句中的语句块。

首先还是获取输入的内容：

String ss2 = ((JButton) e.getSource()).getText();

对于输入的小数点，可能是 str1 的，也有可能是 str2 的，这部分的逻辑与数字的逻辑是相似的。

if (k1 == 1) {
    if (k3 == 1) {
        str1 = "";
        // 还原开关k5状态
        k5 = 1;
    }
    str1 = str1 + ss2;

    k3 = k3 + 1;

    // 显示结果
    result_TextField.setText(str1);

} else if (k1 == 2) {
    if (k4 == 1) {
        str2 = "";
        // 还原开关k5的状态
        k5 = 1;
    }
    str2 = str2 + ss2;

    k4 = k4 + 1;

    result_TextField.setText(str2);
}

最后，为了防止输入小数点之后再次输入小数点，需要进行 k5 = k5 + 1; 的操作。

完整的代码如下：

// 小数点的处理
class Listener_xiaos 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状态
                    k5 = 1;
                }
                str1 = str1 + ss2;

                k3 = k3 + 1;

                // 显示结果
                result_TextField.setText(str1);

            } else if (k1 == 2) {
                if (k4 == 1) {
                    str2 = "";
                    // 还原开关k5的状态
                    k5 = 1;
                }
                str2 = str2 + ss2;

                k4 = k4 + 1;

                result_TextField.setText(str2);
            }
        }

        k5 = k5 + 1;
    }
}

运算符号的响应

注意，运算符的响应定义为局部内部类，与数字键的响应类是相同的。这个局部内部类命令为 Listener_signal，继承 ActionListener 接口。

获取响应事件的源，读取内容，并且将响应源存入 vt 中。

String ss2 = ((JButton) e.getSource()).getText();
store = (JButton) e.getSource();
vt.add(store);

运算符的处理，需要分情况讨论。k2 变量为 1 时，说明这是进行的普通运算操作（比如 2+3，先输入 2，再输入 +，然后输入 3）；如果 k2 > 1 说明进行的是 2+3-9+8 这样的多符号运算（已经输入 2+3，然后输入 - 和 9），即上一次的运算结果存储在 str1 中，符号输入之后要输入的数字是 str2。

• 普通运算操作

当 k2 为 1 时，我们只需要将 k1 开关设置为 2，即接下来输入的数字是 str2。第二个操作数不能以 . 开头，因此将 k5 置为 1。k2 自增 1，如果等会儿还有符号输入，则对应到第二种情况中。

if (k2 == 1) {
    // 开关 k1 为 1 时向数 1 写输入值，为 2 时向数2写输入值。
    k1 = 2;
    k5 = 1;
    signal = ss2;
    k2 = k2 + 1;// 按符号键的次数
} else {
    // ...
}

• 连续运算

else 部分对应这种情况。首先读入上一次的输入（vt 中的第 vt.size()-2 个元素），如果这个输入不是 +、-、*、/ 中的一个，说明是要进行连续运算。

从逻辑上还可以防止连续输入运算符的情况。

此时调用 calc() 进行运算（这个方法是我们自己定义的运算，在 3.9 中实现），将结果存入到 str1 中。

在这个符号之后就是输入操作数 2，因此 k1 置为 2；在输入数字之前不能输入小数点，因此 k5 置为 1；对于连续运算，str2 应该先被清空再输入，因此 k4 置为 1。

singal 存储此次输入的符号。

最后 k2 加 1，增加已经输入的符号的次数。

if (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("/")))

    {
        cal();
        str1 = result;
        // 开关 k1 为 1 时，向数 1 写值，为2时向数2写
        k1 = 2;
        k5 = 1;
        k4 = 1;
        signal = ss2;
    }
    k2 = k2 + 1;
}

完整的代码如下：

// 输入的运算符号的处理
class Listener_signal implements ActionListener {
    @SuppressWarnings("unchecked")
    public void actionPerformed(ActionEvent e) {
        String ss2 = ((JButton) e.getSource()).getText();
        store = (JButton) e.getSource();
        vt.add(store);

        if (k2 == 1) {
            // 开关 k1 为 1 时向数 1 写输入值，为 2 时向数2写输入值。
            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("/")))

            {
                cal();
                str1 = result;
                // 开关 k1 为 1 时，向数 1 写值，为2时向数2写
                k1 = 2;
                k5 = 1;
                k4 = 1;
                signal = ss2;
            }
            k2 = k2 + 1;

        }

    }
}

等于的响应

注意，等于的响应也是定义为局部内部类，与数字键的响应类是相同的。这个局部内部类命令为 Listener_dy，继承 ActionListener 接口。

当等于键按下之后，调用 calc() 进行运算，还原开关的值即可。

最后做了一个操作 str1 = result;，是为了应对 7+5=12 +5=17 这种情况。上一次运算的结果在下一个运算中默认作为第一个操作数。

// 等于按键的逻辑，即在输入完成后开始计算
class Listener_dy implements ActionListener {
    @SuppressWarnings("unchecked")
    public void actionPerformed(ActionEvent e) {

        store = (JButton) e.getSource();
        vt.add(store);
        cal();

        // 还原开关k1状态
        k1 = 1;

        // 还原开关k2状态
        k2 = 1;

        // 还原开关k3状态
        k3 = 1;

        // 还原开关k4状态
        k4 = 1;

        // 为 7+5=12 +5=17 这种计算做准备
        str1 = result;
    }
}

计算逻辑的实现

计算的逻辑要针对输入的不同运算符来对操作数进行运算，同时还要考虑到除以 0 这种不合理的算法容错。

对于计算逻辑，我们写在一个名为 calc() 的成员函数中。

首先要将操作数转为 double 类型，代码中定义了 a2 和 b2 用来存储操作数 1 和 操作数 2。

// 操作数1
double a2;
// 操作数2
double b2;

//...

// 手动只输入一个小数点的问题
if (str1.equals("."))
    str1 = "0.0";
if (str2.equals("."))
    str2 = "0.0";

// 转换字符串为 double
a2 = Double.valueOf(str1).doubleValue();
b2 = Double.valueOf(str2).doubleValue();

还需要定义一个存储中间运算结果的值

// 运算结果
double result2 = 0;

对于运算符号，我们使用一个 String c 来存储。

// 运算符
String c = signal;

if (c.equals("")) {
    // 还没有输入符号，不能计算
    result_TextField.setText("Please input operator");
} else {
    // 可以进行计算

    // 手动只输入一个小数点的问题
    if (str1.equals("."))
        str1 = "0.0";
    if (str2.equals("."))
        str2 = "0.0";

    // 转换字符串为 double
    a2 = Double.valueOf(str1).doubleValue();
    b2 = Double.valueOf(str2).doubleValue();

    //...
}

当上面的运算符判断和操作数转换都完成后，就可以进行加减乘除运算了。要注意，进行乘法时，为了保证精度，可以将 double 存入大的浮点数类 BigDecimal 中。

if (c.equals("")) {
    // 还没有输入符号，不能计算
    result_TextField.setText("Please input operator");
} else {

    //...

    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("")) {
    // 还没有输入符号，不能计算
    result_TextField.setText("Please input operator");
} else {

    //...

    result = ((new Double(result2)).toString());
    result_TextField.setText(result);
}

``

完整代码如下：

```java
// 计算逻辑
public void cal() {
    // 操作数1
    double a2;
    // 操作数2
    double b2;
    // 运算符
    String c = signal;
    // 运算结果
    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;
            }

        }

        result = ((new Double(result2)).toString());
        result_TextField.setText(result);
    }
}

清除的响应

清除的逻辑非常简单，将所有变量的值清空或者置为初始值。

其代码如下：

// 清除键的逻辑（Clear）
class Listener_clear 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();
    }
}

注册监听器

注册各个监听器，即绑定事件响应逻辑到各个 UI 组件上：

// 监听等于键
Listener_dy jt_dy = new Listener_dy();
button_dy.addActionListener(jt_dy);
// 监听数字键
Listener jt = new Listener();
button0.addActionListener(jt);
button1.addActionListener(jt);
button2.addActionListener(jt);
button3.addActionListener(jt);
button4.addActionListener(jt);
button5.addActionListener(jt);
button6.addActionListener(jt);
button7.addActionListener(jt);
button8.addActionListener(jt);
button9.addActionListener(jt);

```java
// 监听符号键
Listener_signal jt_signal = new Listener_signal();
button_jia.addActionListener(jt_signal);
button_jian.addActionListener(jt_signal);
button_cheng.addActionListener(jt_signal);
button_chu.addActionListener(jt_signal);
// 监听清除键
Listener_clear jt_c = new Listener_clear();
clear_Button.addActionListener(jt_c);
// 监听小数点键
Listener_xiaos jt_xs = new Listener_xiaos();
button_Dian.addActionListener(jt_xs);

除了绑定 UI 的响应时间之外，我们还给窗口绑定了一个事件。

// 窗体关闭事件的响应程序
frame.addWindowListener(new WindowAdapter() {
    public void windowClosing(WindowEvent e) {
        System.exit(0);
    }
});

至此，整个计算器的主要逻辑就已经讲解完毕，请自行补充其他的细节。

完成后，请点击菜单中的 Run -> Run 选项或者点击工具栏上方的运行按钮来编译运行这个项目。

如果没有遇到错误，则会弹出计算器的窗口。

你可以试用一下。

源码：

包com.shiyanlou.calculator;

导入 java.awt.*;
导入 java.awt.event.*;
导入 javax.swing.*;
导入 java.util.Vector;
导入 java.math.BigDecimal;

公共类计算器{

    // 鎿滑初綔鏁 1锛屼负浜嗙▼搴忕殑瀹夊叏锛屽垵链间竴瀹氲缃纴杩欓噷鎴剧戜戜域 
	字符串 str1 = "0"; 
	
	// 鎿萌綔鏁 2
	字符串 str2 = "0"; 
	
	//杩愮畻绗 
	字符串信号 = "+"; 
	
	//杩愮畻缁撴灉
	字符串结果 = "";

	// 浠ヤ笅k1钶2三十虹姸镐佸紑鍏 
	
	//寮€鍏 1鐢ㄤ簬阃夋嫨杈揿叆鏂宝石悜锛屽皢瑕佸启鍏tr1鎴杝tr2
	int k1 = 1;
	//寮€鍏 2鐢ㄤ簬璁板綍绗﹀佛阌殑娆℃暟锛屽鏋  k2>1 璇存槑杩涜镄勬槸2+3-9+8勫绗﹀佛杩愮畻
	int k2 = 1;
	// 寮€鍏 3鐢ㄤ簬镕借曲弯瘑 str1 鏄惁鍙互琚绻0 锛岀瓑浜 1镞跺彲浠ワ纴朵苳苕苳栃栃栃栃0
	整数 k3 = 1;
	// 寮€鍏 4鐢ㄤ簬镙六瘑 str2鏄惁鍙互琚竻0
	int k4 = 1;
	// 寮€鏆5鐢ㄤ簬鎺у埗灏忔暟镣瑰彲钖﹁褰曞叆锛岀瓑浜 1镞跺彲浠苺ㄤ彲浠ワ纴叞ワ彴勐勐勐勐勐勐勐勐勐彴杳杳泷彴彴彴彴彴彴彴彴嬾旃旃旃1镣彲钖﹁褰曞叆锛岀瓑浜 1鏁扮偣琚涪鎺 
	int k5 = 1;
	//店面镄勪綔鐢ㄧ被浼间簬瀵勫瓨鍣纴鐢ㄤ簬璁板綍鏄惁杩炵画鎸変笅绗﹀佛阌 
	JButton 商店； 
	
	@SuppressWarnings("rawtypes")
	Vector vt = new Vector(20, 10);

    //澹版槑钖勪釜UI缁勪欢瀵硅薄骞跺垵濮嫔寲
	JFrame frame = new JFrame("计算器");
	JTextField result_TextField = new JTextField(result, 20);
	JButton clear_Button = new JButton("Clear");
	JButton button0 = new JButton("0");
	JButton button1 = new JButton("1");
	JButton button2 = new JButton("2");
	JButton button3 = new JButton("3");
	JButton button4 = new JButton("4");
	JButton button5 = new JButton("5");
	JButton button6 = new JButton("6");
	JButton button7 = new JButton("7");
	JButton button8 = new JButton("8");
	JButton button9 = new JButton("9");
	JButton button_Dian = new JButton(".");
	JButton button_jia = new JButton("+");
	JButton button_jian = new JButton("-");
	JButton button_cheng = new JButton("*");
	JButton button_chu = new JButton("/");
	JButton button_dy = new JButton("=");

    // 璁＄畻链虹被镄勬瀯阃犲櫒
	公共计算器（）{
	
	    // 无限烘寜阍缃瓑鏁堥敭锛屽嵆鍙互阃氲绷瀵魅力簲镄勯敭鐩樻寜錘潵潵栃
		button0.setMnemonic(KeyEvent.VK_0);
		// 鍏跺畠绛夋晥阌渷鐣ワ纴浣犲彲浠ヨ嚜瀚岃ˉ鍏呭畲鏁 

        // 璁剧界鏂囨湰妗嗕负鏂嗕负钍冲榻愶纴浣ュ拰绦緭鍏ュ拰閮介潬鍙樉紫。
		result_TextField.setHorizo​​ntalAlignment(JTextField.RIGHT);

        //灏哢我缁勪欢娣教导姞杩涘鍣ㄥ唴
		JPanel pan = new JPanel();
		pan.setLayout(new GridLayout(4, 4, 5, 5));
		pan.add(button7);
		pan.add(button8);
		pan.add(button9);
		pan.add(button_chu);
		pan.add(button4);
		pan.add(button5);
		pan.add(button6);
		pan.add(button_cheng);
		pan.add(button1);
		pan.add(button2);
		pan.add(button3);
		pan.add(button_jian);
		pan.add(button0);
		pan.add(button_Dian);
		pan.add(button_dy);
		pan.add(button_jia);
		pan.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));

		JPanel pan2 = new JPanel();
		pan2.setLayout(new BorderLayout());
		pan2.add(result_TextField, BorderLayout.WEST);
		pan2.add(clear_Button, BorderLayout.EAST);

        // 璁剧疆界荤獥鍙e嚭鐜板湪灞忓箷串婄殑川崎疆疆域
		frame.setLocation(300, 200);
		// 璁剧疆绐椾綋涓嶈兘冨ぇ灏 
		frame.setResizable(false); 
		frame.getContentPane().setLayout(new BorderLayout());
		frame.getContentPane().add(pan2, BorderLayout.NORTH);
		frame.getContentPane().add(pan, BorderLayout.CENTER);

		框架.pack();
		frame.setVisible(true);

		// 浜嬩欢澶勭悊绋嫔簭

		// 鏁板瓧阌 
		类 Listener 实现 ActionListener {
			@SuppressWarnings("未选中")
			public void actionPerformed(ActionEvent e) {
				String ss = ((JButton) e.getSource()).getText();
				store = (JButton) e.getSource();
				vt.add(store);
				如果（k1 == 1）{
					如果（k3 == 1）{
						str1 = "";
						
						// 杩桦师寮€鍏砶5钟舵€ 
						k5 = 1;
					}
					str1 = str1 + ss;

					k3 = k3 + 1；
                    
                    // 鏄剧ず缁撴灉
					result_TextField.setText(str1);

				} else if (k1 == 2) {
					如果（k4 == 1）{
						str2 = "";
						
						// 杩桦师寮€鍏砶5钟舵€ 
						k5 = 1; 
					}
					str2 = str2 + ss;
					k4 = k4 + 1；
					result_TextField.setText(str2);
				}

			}
		}

		//杈揿叆镄勮繍绠楃鍙风殑澶勭悊
		类 Listener_signal 实现 ActionListener {
			@SuppressWarnings("未选中")
			public void actionPerformed(ActionEvent e) {
				String ss2 = ((JButton) e.getSource()).getText();
				store = (JButton) e.getSource();
				vt.add(store);

				如果（k2 == 1）{
				    //寮€鍏  k1十  1 镞跺悜鏁  1 鍐栾緭鍏ュ€硷纴十 2镞跺悜鏁 2鍐栾緭鍏ュ€笺€ 
					k1 = 2;
					k5 = 1;
					信号 = ss2;
					k2 = k2 + 1;// 鎸夌鍙烽敭镄勬鏁 
				} 别的 {
					int a = vt.size();
					JButton c = (JButton) vt.get(a - 2);

					如果 (!(c.getText().equals("+"))
							&& !(c.getText().equals("-"))
							&& !(c.getText().equals("*"))
							&& !(c.getText().equals("/")))

					{
						校准（）；
						str1 = 结果；
						//寮€鍏  k1十  1 镞泄纴钖戞暟 1 鍐椤€硷纴三 2镞跺悜鏁 2鍐 
						k1 = 2;
						k5 = 1;
						k4 = 1;
						信号 = ss2;
					}
					k2 = k2 + 1；

				}

			}
		}

		// 述呴櫎阌殑阃昏緫锛圕lear锛 
		类 Listener_clear 实现 ActionListener {
			@SuppressWarnings("未选中")
			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";
				信号 = "";
				结果 = "";
				result_TextField.setText(result);
				vt.clear();
			}
		}

		// 绛変簬阌殑阃昏緫
		类 Listener_dy 实现 ActionListener {
			@SuppressWarnings("未选中")
			public void actionPerformed(ActionEvent e) {

				store = (JButton) e.getSource();
				vt.add(store);
				校准（）；
				
				//杩桦师钖勪釜寮€鍏崇殑钟舵€ 
				k1 = 1; 
				k2 = 1;
				k3 = 1;
				k4 = 1;

				str1 = 结果； 
			}
		}
		
		// 灏忔暟镣圭殑澶勭悊
		类 Listener_xiaos 实现 ActionListener {
			@SuppressWarnings("未选中")
			public void actionPerformed(ActionEvent e) {
				store = (JButton) e.getSource();
				vt.add(store);
				如果（k5 == 1）{
					String ss2 = ((JButton) e.getSource()).getText();
					如果（k1 == 1）{
						如果（k3 == 1）{
							str1 = "";
							// 杩桦师寮€鍏砶5钟舵€ 
							k5 = 1; 
						}
						str1 = str1 + ss2;

						k3 = k3 + 1；

                        // 鏄剧ず缁撴灉
						result_TextField.setText(str1);

					} else if (k1 == 2) {
						如果（k4 == 1）{
							str2 = "";
							// 杩桦师寮€鍏砶5镄勭姸镐。
							k5 = 1;
						}
						str2 = str2 + ss2;

						k4 = k4 + 1；

						result_TextField.setText(str2);
					}
				}

				k5 = k5 + 1；
			}
		}

		//娉ㄥ唽钖勪釜鐩戝惉鍣纴鍗崇粦瀹氩簨浠跺搷搴旈€昏緫鍒板悇三猆I缁勪欢三
		Listener_dy jt_dy = 新的 Listener_dy();
		
		// 鐩戝惉鏁板瓧阌 
		监听器 jt = 新监听器();
		// 鐩戝惉绗﹀佛阌 
		Listener_signal jt_signal = 新的 Listener_signal();
		// 鐩戝惉述呴櫎阌 
		Listener_clear jt_c = new Listener_clear(); 
		//鐩戝惉灏忔暟镣归敭
		Listener_xiaos jt_xs = new Listener_xiaos();

		button7.addActionListener(jt);
		button8.addActionListener(jt);
		button9.addActionListener(jt);
		button_chu.addActionListener(jt_signal);
		button4.addActionListener(jt);
		button5.addActionListener(jt);
		button6.addActionListener(jt);
		button_cheng.addActionListener(jt_signal);
		button1.addActionListener(jt);
		button2.addActionListener(jt);
		button3.addActionListener(jt);
		button_jian.addActionListener(jt_signal);
		button0.addActionListener(jt);
		button_Dian.addActionListener(jt_xs);
		button_dy.addActionListener(jt_dy);
		button_jia.addActionListener(jt_signal);
		clear_Button.addActionListener(jt_c);

		// 绐椾綋鍏抽棴浜嬩欢镄勫搷搴旗▼搴 
		frame.addWindowListener(new WindowAdapter() {
			公共无效窗口关闭（WindowEvent e）{
				System.exit(0);
			}
		});

	}

	// 璁＄畻阃昏緫
	公共无效校准（）{
    	// 鎿萌綔鏁 1
		双a2;
		// 鎿萌綔鏁 2
		双 b2;
		//杩愮畻绗 
		字符串 c = 信号；
		//杩愮畻缁撴灉
		双结果2 = 0;

		如果（c.equals（“”））{
			result_TextField.setText("请输入运算符");

		} 别的 {
            // 镓嫔姩澶勭悊灏忔暟镣圭殑闂
			如果 (str1.equals("."))
				str1 = "0.0";
			如果 (str2.equals("."))
				str2 = "0.0";
			a2 = Double.valueOf(str1).doubleValue();
			b2 = Double.valueOf(str2).doubleValue();

			如果（c.equals（“+”））{
				结果2 = a2 + b2;
			}
			如果（c.equals（“-”））{
				结果2 = a2 - b2;
			}
			如果（c.equals（“*”））{
				BigDecimal m1 = new BigDecimal(Double.toString(a2));
			        BigDecimal m2 = new BigDecimal(Double.toString(b2));
			        result2 = m1.multiply(m2).doubleValue();
			}
			如果（c.equals（“/”））{
				如果（b2 == 0）{
					结果2 = 0;
				} 别的 {
					结果2 = a2 / b2;
				}

			}

			结果 = ((new Double(result2)).toString());

			result_TextField.setText(result);
		}
	}

	@SuppressWarnings("未使用")
	公共静态无效主（字符串 [] args）{
		// 璁剧界绋嫔簭鏄剧ず镄勭晫闱㈤镙硷纴鍙互信铡婚櫎
	尝试 {
			UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel");
		} 捕获（异常 e）{
			e.printStackTrace();
		}
		计算器 cal = new Calculator();
	}

}

这篇关于Java版图形界面计算器的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！