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

，先輸入

，再輸入

，然後輸入

）；如果 k2 > 1 說明進行的是 2+3-9+8 這樣的多符号運算（已經輸入

2+3

，然後輸入

和

），即上一次的運算結果存儲在 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

選項或者點選工具欄上方的運作按鈕來編譯運作這個項目。

如果沒有遇到錯誤，則會彈出電腦的視窗。

package com.shiyanlou.calculator;

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

public class Calculator {

    // 操作數1，為了程式的安全，初值一定設定，這裡我們設定為0。
    String str1 = "0"; 
    
    // 操作數2
    String str2 = "0"; 
    
    // 運算符
    String signal = "+"; 
    
    // 運算結果
    String result = "";

    // 以下k1至k2為狀态開關
    
    // 開關1用于選擇輸入方向，将要寫入str1或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
    int k4 = 1;
    // 開關5用于控制小數點可否被錄入，等于1時可以，不為1時，輸入的小數點被丢掉
    int k5 = 1;
    // store的作用類似于寄存器，用于記錄是否連續按下符号鍵
    JButton store; 
    
    @SuppressWarnings("rawtypes")
    Vector vt = new Vector(20, 10);

    // 聲明各個UI元件對象并初始化
    JFrame frame = new JFrame("Calculator");
    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("=");

    // 計算機類的構造器
    public Calculator() {
    
        // 為按鈕設定等效鍵，即可以通過對應的鍵盤按鍵來代替點選它
        button0.setMnemonic(KeyEvent.VK_0);
        // 其它等效鍵省略，你可以自行補充完整

        // 設定文本框為右對齊，使輸入和結果都靠右顯示
        result_TextField.setHorizontalAlignment(JTextField.RIGHT);

        // 将UI元件添加進容器内
        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);

        // 設定主視窗出現在螢幕上的位置
        frame.setLocation(300, 200);
        // 設定窗體不能調大小
        frame.setResizable(false); 
        frame.getContentPane().setLayout(new BorderLayout());
        frame.getContentPane().add(pan2, BorderLayout.NORTH);
        frame.getContentPane().add(pan, BorderLayout.CENTER);

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

        // 事件處理程式

        // 數字鍵
        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);
                }

            }
        }

        // 輸入的運算符号的處理
        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;

                }

            }
        }

        // 清除鍵的邏輯（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();
            }
        }

        // 等于鍵的邏輯
        class Listener_dy implements ActionListener {
            @SuppressWarnings("unchecked")
            public void actionPerformed(ActionEvent e) {

                store = (JButton) e.getSource();
                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);
                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;
            }
        }

        // 注冊各個監聽器，即綁定事件響應邏輯到各個UI元件上
        Listener_dy jt_dy = new Listener_dy();
        
        // 監聽數字鍵
        Listener jt = new Listener();
        // 監聽符号鍵
        Listener_signal jt_signal = new 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() {
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });

    }

    // 計算邏輯
    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);
        }
    }

    @SuppressWarnings("unused")
    public static void main(String[] args) {
        // 設定程式顯示的界面風格，可以去除
    try {
            UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel");
        } catch (Exception e) {
            e.printStackTrace();
        }
        Calculator cal = new Calculator();
    }

}

Java版圖形界面電腦