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.uj5u.com/houduan/404326.html

標籤：Java

上一篇：Spring Boot 入門（十四）使用dubbo(用redis作為注冊中心)

下一篇：【JS 逆向百例】PEDATA 加密資訊以及 zlib.gunzipSync() 的應用

【計項02組01號】Java版圖形界面計算器【1.0】

Java版圖形界面計算器1.0版本

專案分析【1.0】

源代碼【1.0】