您现在的位置是:首页 > 编程语言 > 其他编程其他编程

【计项02组01号】Java版图形界面计算器【1.0】

2022-01-07 00:05:50其他编程人已围观

简介博客推行版本更新,成果积累制度,已经写过的博客还会再次更新,不断地琢磨,高质量高数量都是要追求的,工匠精神是学习必不可少的精神。因此,大家有何建议欢迎在评论区踊跃发言,你们的支持是我最大的动力,你们敢

Java版图形界面计算器1.0版本

项目分析【1.0】

组成部分

代码结构

(1)窗口的创建

在《JDK 核心 API》中我们提到,创建一个窗口需要使用 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("=");

(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);
    }
});

实验总结

查看代码
try {
    UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
} catch(Exception e) {
    e.printStackTrace();
}

通过 UIManager 来设置窗体的 UI 风格,如果需要更改,只要做相应的替换就可以了:

  • Windows 风格:com.sun.java.swing.plaf.windows.WindowsLookAndFeel
  • Metal 风格(默认):javax.swing.plaf.metal.MetalLookAndFeel
  • 更换为 Motif 风格:com.sun.java.swing.plaf.motif.MotifLookAndFeel
  • 更换为 Mac 风格:com.sun.java.swing.plaf.mac.MacLookAndFeel
  • 更换为 GTK 风格:com.sun.java.swing.plaf.gtk.GTKLookAndFeel

源代码【1.0】

查看代码
package com.shiyanlou.calculator;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.Vector;
import java.math.BigDecimal;
import javax.swing.UIManager;

public class Calculator {  
    String str1="0"; // 操作数1,为了程序的安全,初值设置为0
    String str2="0"; // 操作数2
    String signal="+"; // 运算符
    String result="";// 运算结果
    
    // 以下k1至k2为状态开关
    int k1=1;// 开关1用于选择输入方向,将要写入str1或str2
    int k2=1;// 开关2用于记录符号键的次数,如果 k2>1 说明进行的是多符号运算
    int k3=1;// 开关3用于标识 str1 是否可以被清0 ,等于1时可以,不等于1时不能被清0
    int k4=1;// 开关4用于标识 str2 是否可以被清0,等于1时可以,不等于1时不能被清0
    int k5=1;// 开关5用于控制小数点可否被录入,等于1时可以,不为1时,输入的小数点被丢掉
    JButton store; // store的作用类似于寄存器,用于记录是否连续按下符号键
    
    @SuppressWarnings("rawtypes")//忽略rawtypes警告信息
    Vector vt=new Vector(20, 10);
  
    // 声明各个UI组件对象并初始化
    JFrame frame=new JFrame("Calculator");//JFrame是java里的一个窗体类,创建一个JFrame类的实例
    JTextField result_TextField=new JTextField(result, 20);//JTextField是一个轻量级组件,允许编辑单行文本,构造一个用result和20列的新TextField
    JButton clear_Button=new JButton("AC");//创建AC按钮
    JButton button0=new JButton("0");//创建0按钮
    JButton button1=new JButton("1");//创建1按钮
    JButton button2=new JButton("2");//创建2按钮
    JButton button3=new JButton("3");//创建3按钮
    JButton button4=new JButton("4");//创建4按钮
    JButton button5=new JButton("5");//创建5按钮
    JButton button6=new JButton("6");//创建6按钮
    JButton button7=new JButton("7");//创建7按钮
    JButton button8=new JButton("8");//创建8按钮
    JButton button9=new JButton("9");//创建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("=");//创建=按钮
   
    // 计算机类的构造器
    public Calculator() {
        
        // 为按钮设置等效键,可以通过对应的键盘按键来代替点击它
        button0.setMnemonic(KeyEvent.VK_0);//按下Alt+0
        button1.setMnemonic(KeyEvent.VK_1);//按下Alt+1
        button2.setMnemonic(KeyEvent.VK_2);//按下Alt+2
        button3.setMnemonic(KeyEvent.VK_3);//按下Alt+3
        button4.setMnemonic(KeyEvent.VK_4);//按下Alt+4
        button5.setMnemonic(KeyEvent.VK_5);//按下Alt+5
        button6.setMnemonic(KeyEvent.VK_6);//按下Alt+6
        button7.setMnemonic(KeyEvent.VK_7);//按下Alt+7
        button8.setMnemonic(KeyEvent.VK_8);//按下Alt+8
        button9.setMnemonic(KeyEvent.VK_9);//按下Alt+9
        
        // 设置文本框为右对齐,使输入和结果都靠右显示
        result_TextField.setHorizontalAlignment(JTextField.RIGHT);

        // 将UI组件添加进容器内
        JPanel pan = new JPanel();//创建面板组件的一个实例pan
        pan.setLayout(new GridLayout(4, 4, 5, 5));//设置4行4列边距为5像素的表格布局
        pan.add(button7);//设置pan对象的边距
        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));//创建一个框,头部、底部、左、右都为5像素
        JPanel pan2=new JPanel();
        pan2.setLayout(new BorderLayout());//设置布局为边框布局,分东南西北中5个方位
        pan2.add(result_TextField, BorderLayout.WEST);//将显示结果的文本框添加到pan2
        pan2.add(clear_Button, BorderLayout.EAST);//将AC按钮添加到pan2

        // 设置主窗口出现在屏幕上的位置
        frame.setLocation(300, 200);//窗口最初位置
        frame.setResizable(false); // 设置窗体不能调大小
        frame.getContentPane().setLayout(new BorderLayout());//设置一个具有hgap为横向间距、vgap为纵向间距的边框布局
        frame.getContentPane().add(pan2, BorderLayout.NORTH);//将pan2放到边框上方
        frame.getContentPane().add(pan, BorderLayout.CENTER);//将pan放到边框中间
        frame.pack();//根据窗口里面的布局及组件的preferedSize来确定frame的最佳大小
        frame.setVisible(true);//窗口显示frame对象

        // 事件处理程序

        // 数字键响应事件
        class Listener implements ActionListener {
            @SuppressWarnings("unchecked")//忽略unchecked的警告信息
            public void actionPerformed(ActionEvent e) {
                String ss=((JButton) e.getSource()).getText();//获取事件源,并从事件源获取输入数据
                store=(JButton) e.getSource();//读取存储的符号键
                vt.add(store);//将符号键添加到vt中
                if (k1==1) //输入是操作数1的部分,判断是否可以清零
                {
                    if (k3==1) 
                    {
                        str1="";
                        k5=1;// 还原开关k5状态
                    }
                    str1=str1+ss;//当输入完成后,需要给 k3 的值加 1,保证 操作数 1 不会被清空。并且还需要将操作数 1 打印到结果栏
                    k3=k3+1;
                    result_TextField.setText(str1);// 显示结果
                }
                else if (k1==2) //输入操作数是2的部分,判断是否可以清零
                {
                    if (k4==1) 
                    {
                        str2="";
                        k5=1; // 还原开关k5状态
                    }
                    str2=str2+ss;//当输入完成后,需要给 k4 的值加 1,保证 操作数 2 不会被清空。并且还需要将操作数 2 打印到结果栏
                    k4=k4+1;
                    result_TextField.setText(str2);//显示结果
                }

            }
        }

        // 输入的运算符号的处理
        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);//将符号键添加到vt中去
                if (k2==1) 
                {
                    k1=2;// 开关 k1 为 1 时向数 1 写输入值,为2时向数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();//调用calc()运算并将结果存入str1中
                        str1=result;
                        k1=2;// 开关 k1 为 1 时,向数 1 写值,为2时向数2输入
                        k5=1;//可以输入小数点
                        k4=1;//可以连续计算
                        signal=ss2;//signal存储此次输入的符号
                    }
                    k2=k2+1;//增加已经输入的符号的次数
                }
            }
        }

        // 清除键的逻辑(Clear)
        class Listener_clear implements ActionListener {
            @SuppressWarnings("unchecked")
            public void actionPerformed(ActionEvent e) {
                store=(JButton) e.getSource();//读入存储的符号键
                vt.add(store);//将符号键添加到vt中去
                k5=1;//将所有的值清零或置为初值
                k2=1;
                k1=1;
                k3=1;
                k4=1;
                str1="0";
                str2="0";
                signal="";
                result="";
                result_TextField.setText(result);//显示结果
                vt.clear();
            }
        }

        // 等于键的逻辑
        class Listener_dy implements ActionListener {
            @SuppressWarnings("unchecked")
            public void actionPerformed(ActionEvent e) {
                store=(JButton) e.getSource();//按键按下后,调用calc()函数,还原开关的值
                vt.add(store);
                cal();
                
                // 还原各个开关的状态
                k1=1; 
                k2=1;
                k3=1;
                k4=1;
                str1=result; 
            }
        }
        
        // 小数点的处理
        class Listener_xiaos implements ActionListener {
            @SuppressWarnings("unchecked")
            public void actionPerformed(ActionEvent e) {
                store=(JButton) e.getSource();//获取相应源
                vt.add(store);//将相应源添加到vt中去
                if (k5==1) 
                {
                    String ss2=((JButton) e.getSource()).getText();//获取事件源,并从事件源获取输入的数据
                    if (k1==1) //输入是操作数1的部分,判断是否可以清零
                    {
                        if (k3==1) 
                        {
                            str1="";
                            k5=1; // 还原开关k5状态
                        }
                        str1=str1+ss2;
                        k3=k3+1;
                        result_TextField.setText(str1);//显示结果

                    } 
                    else if (k1==2) //输入是操作数2的部分,判断是否可以清零
                    {
                        if (k4==1) 
                        {
                            str2="";
                            k5=1;// 还原开关k5的状态
                        }
                        str2=str2+ss2;
                        k4=k4+1;
                        result_TextField.setText(str2);//显示结果
                    }
                }
                k5=k5+1;
            }
        }
        
        // 注册各个监听器,即绑定事件响应逻辑到各个UI组件上
        
        //监听等于键
        Listener_dy jt_dy=new Listener_dy();
        button_dy.addActionListener(jt_dy);
        
        // 监听数字键
        Listener jt=new Listener();
        button7.addActionListener(jt);
        button8.addActionListener(jt);
        button9.addActionListener(jt);
        button4.addActionListener(jt);
        button5.addActionListener(jt);
        button6.addActionListener(jt);
        button1.addActionListener(jt);
        button2.addActionListener(jt);
        button3.addActionListener(jt);
        button0.addActionListener(jt);
        // 监听符号键
        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);

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

    // 计算逻辑
    public void cal() {
        double a2;// 操作数1
        double b2;// 操作数2
        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();//转换字符串为double型
            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));//为保证精度,将double存入大的浮点数类型BigDecimal中
                    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);
        }
    }
    @SuppressWarnings("unused")
    public static void main(String[] args) {
        // 设置程序显示的界面风格
    try {
            UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.WindowaLookAndFeel");//Windows窗体风格
            /*Metal 风格(默认):javax.swing.plaf.metal.MetalLookAndFeel
            更换为 Motif 风格:com.sun.java.swing.plaf.motif.MotifLookAndFeel
            更换为 Mac 风格:com.sun.java.swing.plaf.mac.MacLookAndFeel
            更换为 GTK 风格:com.sun.java.swing.plaf.gtk.GTKLookAndFeel*/
        } 
    catch (Exception e) 
    {
            e.printStackTrace();
    }
        Calculator cal=new Calculator();
    }
}
在黑夜里梦想着光,心中覆盖悲伤,在悲伤里忍受孤独,空守一丝温暖。 我的泪水是无底深海,对你的爱已无言,相信无尽的力量,那是真爱永在。 我的信仰是无底深海,澎湃着心中火焰,燃烧无尽的力量,那是忠诚永在

文章来源:https://www.cnblogs.com/yyyyfly1/p/15773012.html

Tags:版图 计算器 界面 java 1.0 

很赞哦! ()

文章评论

留言与评论(共有 0 条评论)
   
验证码:

本栏推荐

站点信息

  • 文章统计1087092篇文章
  • 浏览统计38200次浏览
  • 评论统计2个评论
  • 标签管理标签云
  • 统计数据:统计代码
  • 微信公众号:扫描二维码,关注我们