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

yyyyfly發表於2022-01-06
Java

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

專案分析【1.0】

組成部分

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

程式碼結構

【計項02組01號】Java版圖形介面計算器【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。

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

什麼是 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... 的順序進行填充。

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

對比之前的效果圖，我們應該按照下面的順序進行 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）。如下圖所示：

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

檢視程式碼 
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();
    }
}

相關文章