一、數據類型和變量宣告（閱讀和實踐）

1. 基本數據類型（Primitive Data Types）

Java中有八種類型的基本數據類型：

整數型:
- byte（8位）：範圍是 -128 到 127
- short（16位）：範圍是 -32,768 到 32,767
- int（32位）：範圍是 -2^31 到 2^31-1
- long（64位）：範圍是 -2^63 到 2^63-1，需在數字後加 "L"
浮點數型:
- float（32位）：單精度浮點數，需在數字後加 "F"
- double（64位）：雙精度浮點數，默認的浮點數類型
字符型:
- char（16位）：單個字符，例如 'a', 'A', '1', '漢'
布爾型:
- boolean：僅有兩個值：true 或 false

2. 變量宣告（Variable Declaration）

在Java中，變量需要先宣告後才能使用。宣告變量的語法如下：

type variableName = initialValue;

type：變量的數據類型（如 int, double, char 等）
variableName：變量名稱，需遵循命名規則
initialValue（可選）：變量的初始值

例子

int age = 25;           // 整數型變量
double salary = 55000.50; // 浮點數型變量
char grade = 'A';        // 字符型變量
boolean isJavaFun = true; // 布爾型變量

3. 變量的作用域（Scope of Variables）

變量的作用域是指變量在程序中可訪問的範圍。Java中的變量主要有三種作用域：

局部變量（Local Variables）：在方法內部宣告，僅在方法內部可見。
實例變量（Instance Variables）：在類中但在方法外宣告，對象實例使用這些變量。
類變量（Class Variables，也稱靜態變量 Static Variables）：用 static 關鍵字宣告，在整個類中共享。

4. 常量（Constants）

如果某個變量的值在程序執行期間不會改變，可以使用 final 關鍵字將其聲明為常量。

final int MAX_AGE = 100;

5. 實踐練習

你可以通過以下簡單的練習來鞏固所學知識：

練習 1: 宣告並初始化各種類型的變量

public class DataTypePractice {
    public static void main(String[] args) {
        // 整數型
        byte b = 10;
        short s = 100;
        int i = 1000;
        long l = 10000L;

        // 浮點數型
        float f = 10.5F;
        double d = 20.5;

        // 字符型
        char c = 'A';

        // 布爾型
        boolean isJavaFun = true;

        // 常量
        final int MAX_VALUE = 100;

        // 輸出變量值
        System.out.println("byte: " + b);
        System.out.println("short: " + s);
        System.out.println("int: " + i);
        System.out.println("long: " + l);
        System.out.println("float: " + f);
        System.out.println("double: " + d);
        System.out.println("char: " + c);
        System.out.println("boolean: " + isJavaFun);
        System.out.println("final int: " + MAX_VALUE);
    }
}

練習 2: 嘗試更改常量的值並觀察錯誤

final int MAX_VALUE = 100;
MAX_VALUE = 200; // 這行代碼會產生編譯錯誤

這些練習可以幫助你掌握Java中數據類型和變量宣告的基本概念。如果你在練習過程中遇到任何問題，隨時可以告訴我！

—

複習運算符和表達式時，我們將探討Java中的各種運算符類型以及它們的使用方法，然後通過練習來加深理解。

二、運算符和表達式

1. 運算符概述

Java中的運算符可以分為幾個主要類型：

算術運算符（Arithmetic Operators）
關係運算符（Relational Operators）
邏輯運算符（Logical Operators）
位元運算符（Bitwise Operators）
賦值運算符（Assignment Operators）
增量與減量運算符（Increment/Decrement Operators）
條件運算符（三元運算符 Ternary Operator）

2. 各類運算符的詳細介紹

2.1 算術運算符（Arithmetic Operators）

加法（+）：a + b
減法（-）：a - b
乘法（*）：a * b
除法（/）：a / b
取餘（%）：a % b

2.2 關係運算符（Relational Operators）

等於（==）：a == b
不等於（!=）：a != b
大於（>）：a > b
小於（<）：a < b
大於等於（>=）：a >= b
小於等於（<=）：a <= b

2.3 邏輯運算符（Logical Operators）

邏輯與（&&）：a && b
邏輯或（||）：a || b
邏輯非（!）：!a

2.4 位元運算符（Bitwise Operators）

按位與（&）：a & b
按位或（|）：a | b
按位非（~）：~a
按位異或（^）：a ^ b
左移（<<）：a << n
右移（>>）：a >> n
無符號右移（>>>）：a >>> n

2.5 賦值運算符（Assignment Operators）

賦值（=）：a = b
加等於（+=）：a += b （相當於 a = a + b）
減等於（-=）：a -= b （相當於 a = a - b）
乘等於（*=）：a *= b （相當於 a = a * b）
除等於（/=）：a /= b （相當於 a = a / b）
取餘等於（%=）：a %= b （相當於 a = a % b）

2.6 增量與減量運算符（Increment/Decrement Operators）

前增量（++a）：先增加後使用
後增量（a++）：先使用後增加
前減量（--a）：先減少後使用
後減量（a--）：先使用後減少

2.7 條件運算符（三元運算符 Ternary Operator）

條件運算符：condition ? expression1 : expression2
- 如果條件為 true，返回 expression1 的值；否則返回 expression2 的值。

3. 實踐練習

以下是一些簡單的練習，可以幫助你更好地理解這些運算符的應用。

練習 1: 算術運算符

public class ArithmeticOperators {
    public static void main(String[] args) {
        int a = 10, b = 5;
        System.out.println("a + b = " + (a + b)); // 15
        System.out.println("a - b = " + (a - b)); // 5
        System.out.println("a * b = " + (a * b)); // 50
        System.out.println("a / b = " + (a / b)); // 2
        System.out.println("a % b = " + (a % b)); // 0
    }
}

練習 2: 關係和邏輯運算符

public class RelationalLogicalOperators {
    public static void main(String[] args) {
        int a = 10, b = 5;
        System.out.println("a > b = " + (a > b));  // true
        System.out.println("a < b = " + (a < b));  // false
        System.out.println("a == b = " + (a == b)); // false
        System.out.println("a != b = " + (a != b)); // true

        boolean result = (a > b) && (b > 0); // true
        System.out.println("(a > b) && (b > 0) = " + result);
    }
}

練習 3: 賦值運算符和增量/減量運算符

public class AssignmentIncrementOperators {
    public static void main(String[] args) {
        int a = 10;
        a += 5; // 相當於 a = a + 5
        System.out.println("a += 5 = " + a); // 15

        int b = 10;
        System.out.println("b++ = " + (b++)); // 10 (使用後增加)
        System.out.println("++b = " + (++b)); // 12 (增加後使用)
    }
}

練習 4: 三元運算符

public class TernaryOperator {
    public static void main(String[] args) {
        int a = 10, b = 5;
        String result = (a > b) ? "a is greater" : "b is greater";
        System.out.println(result); // "a is greater"
    }
}

三、控制結構（if, switch）

在Java中，控制結構（Control Structures）用於控制程式的執行流程，其中 if 和 switch 是兩種最常見的選擇結構（Selection Structures）。它們允許程式根據條件的結果來決定執行哪一段代碼。

1. `if` 控制結構

if 控制結構根據一個或多個條件表達式的結果來決定是否執行某段代碼。這些條件通常是布爾表達式，即它們的結果為 true 或 false。

1.1 基本語法

if (condition) {
    // 當condition為true時執行的代碼
}

1.2 `if-else` 語法

如果條件為 false，則可以使用 else 來執行另一段代碼。

if (condition) {
    // 當condition為true時執行的代碼
} else {
    // 當condition為false時執行的代碼
}

1.3 `if-else if-else` 語法

當有多個條件需要檢查時，可以使用 else if 來鏈接多個條件。

if (condition1) {
    // 當condition1為true時執行的代碼
} else if (condition2) {
    // 當condition1為false且condition2為true時執行的代碼
} else {
    // 當所有條件都為false時執行的代碼
}

1.4 範例

public class IfElseExample {
    public static void main(String[] args) {
        int num = 10;

        if (num > 0) {
            System.out.println("The number is positive.");
        } else if (num < 0) {
            System.out.println("The number is negative.");
        } else {
            System.out.println("The number is zero.");
        }
    }
}

解釋: 在這個例子中，如果 num 大於 0，則打印 "The number is positive."，如果小於 0，則打印 "The number is negative."，如果等於 0，則打印 "The number is zero."

2. `switch` 控制結構

switch 控制結構用於根據變量的值來選擇多個代碼塊中的一個來執行。這在處理多個選擇時比使用大量的 if-else 更加清晰和高效。

2.1 基本語法

switch (expression) {
    case value1:
        // 當expression等於value1時執行的代碼
        break;
    case value2:
        // 當expression等於value2時執行的代碼
        break;
    // 你可以添加更多的case
    default:
        // 當expression不等於任何case值時執行的代碼
        break;
}

**break**: break 用來退出 switch 結構。如果省略 break，程式將繼續執行下一個 case，這稱為「穿透」。
**default**: default 是可選的，當 expression 不匹配任何 case 時執行 default 代碼塊。

2.2 範例

public class SwitchExample {
    public static void main(String[] args) {
        int day = 3;
        String dayName;

        switch (day) {
            case 1:
                dayName = "Sunday";
                break;
            case 2:
                dayName = "Monday";
                break;
            case 3:
                dayName = "Tuesday";
                break;
            case 4:
                dayName = "Wednesday";
                break;
            case 5:
                dayName = "Thursday";
                break;
            case 6:
                dayName = "Friday";
                break;
            case 7:
                dayName = "Saturday";
                break;
            default:
                dayName = "Invalid day";
                break;
        }

        System.out.println("Day " + day + " is " + dayName);
    }
}

解釋: 在這個例子中，變量 day 的值是 3，程式會匹配 case 3，然後將 dayName 設為 "Tuesday" 並打印出來。

3. `if` 和 `switch` 的區別

用途: if 用於處理布爾條件，適合複雜的條件判斷；switch 適合處理具體值的選擇，如枚舉類型、整數類型等。
可讀性: 當處理多個選擇時，switch 結構通常比一連串的 if-else 更加清晰。
效率: 在某些情況下，switch 可能比多個 if-else 更高效，特別是當 case 很多時。

4. 實踐練習

練習 1: 使用 `if-else` 控制結構

public class IfElsePractice {
    public static void main(String[] args) {
        int score = 85;

        if (score >= 90) {
            System.out.println("Grade: A");
        } else if (score >= 80) {
            System.out.println("Grade: B");
        } else if (score >= 70) {
            System.out.println("Grade: C");
        } else if (score >= 60) {
            System.out.println("Grade: D");
        } else {
            System.out.println("Grade: F");
        }
    }
}

練習 2: 使用 `switch` 控制結構

public class SwitchPractice {
    public static void main(String[] args) {
        char grade = 'B';

        switch (grade) {
            case 'A':
                System.out.println("Excellent!");
                break;
            case 'B':
            case 'C':
                System.out.println("Well done");
                break;
            case 'D':
                System.out.println("You passed");
                break;
            case 'F':
                System.out.println("Better try again");
                break;
            default:
                System.out.println("Invalid grade");
                break;
        }
    }
}

為何在 switch 中使用 break 而不是 return

在 switch 中使用 break 而不是 return

是因為 break 用來退出 switch 結構並繼續執行 switch 之後的代碼。

而 return 則會直接退出當前方法，不會執行 switch 之後的代碼。因此，break 適用於需要在 switch 結構後繼續執行其他代碼的情況，而 return 則適用於需要立即退出方法的情況。

四、控制結構（for, while, do-while）

控制結構中的迴圈結構（Loop Structures）允許我們重複執行某段代碼。Java中的主要迴圈結構包括 for、while 和 do-while。

1. `for` 迴圈

for 迴圈通常用於在已知確切迭代次數的情況下使用。它是一個集成的迴圈結構，將初始化、條件檢查和增量操作集中在一個語句中。

1.1 基本語法

for (initialization; condition; update) {
    // 迴圈中要重複執行的代碼
}

initialization: 迴圈開始前執行的初始化操作，通常是變量的宣告和賦值。
condition: 在每次迭代前檢查的條件，當條件為 true 時，迴圈繼續執行；當條件為 false 時，迴圈終止。
update: 每次迭代後執行的操作，通常用來更新迴圈變量。

1.2 範例

public class ForLoopExample {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            System.out.println("Iteration: " + i);
        }
    }
}

解釋: 這個 for 迴圈從 i = 0 開始，當 i < 5 時迴圈繼續，每次迭代後 i 增加1。這將打印 0 到 4 的值。

2. `while` 迴圈

while 迴圈在每次迭代前檢查條件，並在條件為 true 時繼續執行迴圈體內的代碼。

2.1 基本語法

while (condition) {
    // 迴圈中要重複執行的代碼
}

condition: 這是布爾表達式，當條件為 true 時，迴圈繼續執行；當條件為 false 時，迴圈終止。

2.2 範例

public class WhileLoopExample {
    public static void main(String[] args) {
        int i = 0;
        while (i < 5) {
            System.out.println("Iteration: " + i);
            i++;
        }
    }
}

解釋: 這個 while 迴圈從 i = 0 開始，當 i < 5 時迴圈繼續，每次迭代後 i 增加1。這將打印 0 到 4 的值。

3. `do-while` 迴圈

do-while 迴圈與 while 迴圈類似，但不同的是，它保證至少執行一次迴圈體，因為條件是在每次迭代後檢查的。

3.1 基本語法

do {
    // 迴圈中要重複執行的代碼
} while (condition);

condition: 這是布爾表達式，當條件為 true 時，迴圈繼續執行；當條件為 false 時，迴圈終止。

3.2 範例

public class DoWhileLoopExample {
    public static void main(String[] args) {
        int i = 0;
        do {
            System.out.println("Iteration: " + i);
            i++;
        } while (i < 5);
    }
}

解釋: 這個 do-while 迴圈與 while 迴圈類似，但即使在初始條件不成立的情況下，也會至少執行一次迴圈體中的代碼。這將打印 0 到 4 的值。
do-while 循環與 while 循環的主要區別在於執行條件的檢查時間點：

簡而言之，do-while 保證循環體至少執行一次，而 while 可能一次也不執行。

4. 迴圈中的控制語句

在迴圈中，我們經常使用一些控制語句來更靈活地控制迴圈的執行：

**break**: 終止迴圈的執行並跳出迴圈。
**continue**: 跳過當前迭代，直接進入下一次迭代。

4.1 範例：`break` 和 `continue`

public class LoopControlExample {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            if (i == 5) {
                break;  // 當 i 等於 5 時，終止迴圈
            }
            if (i % 2 == 0) {
                continue;  // 當 i 是偶數時，跳過當前迭代
            }
            System.out.println("Iteration: " + i);
        }
    }
}

解釋: 在這個範例中，當 i 等於 5 時，break 語句將終止迴圈。當 i 是偶數時，continue 語句將跳過當前迭代。

5. 實踐練習

練習 1: 使用 `for` 迴圈

public class ForLoopPractice {
    public static void main(String[] args) {
        // 打印從 1 到 10 的數字
        for (int i = 1; i <= 10; i++) {
            System.out.println(i);
        }
    }
}

練習 2: 使用 `while` 迴圈

public class WhileLoopPractice {
    public static void main(String[] args) {
        int i = 1;
        // 使用 while 迴圈打印從 1 到 10 的數字
        while (i <= 10) {
            System.out.println(i);
            i++;
        }
    }
}

練習 3: 使用 `do-while` 迴圈

public class DoWhileLoopPractice {
    public static void main(String[] args) {
        int i = 1;
        // 使用 do-while 迴圈打印從 1 到 10 的數字
        do {
            System.out.println(i);
            i++;
        } while (i <= 10);
    }
}

五、基礎練習題

在8月12日的基礎練習題中，我們將概括並應用前四天學習的內容，即Java中的數據類型、變量宣告、運算符和表達式，以及控制結構（if, switch, for, while, do-while）。

基礎練習題概述

這些練習題將幫助你鞏固以下幾個方面的知識：

數據類型和變量宣告
運算符和表達式
控制結構（**if**, **switch**, **for**, **while**, **do-while**）

練習題 1: 基本計算器

任務: 創建一個簡單的計算器程式，它可以執行加法、減法、乘法和除法。

import java.util.Scanner;

public class BasicCalculator {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

	//Scanner 是 Java 中的一個類，用於從用戶輸入中讀取數據。
	//nextDouble 是 Scanner 類中的一個方法，用於讀取用戶輸入的下一個雙精度浮點數（double）。
        System.out.println("Enter first number:");
        double num1 = scanner.nextDouble();

        System.out.println("Enter second number:");
        double num2 = scanner.nextDouble();

        System.out.println("Enter an operator (+, -, *, /):");
        char operator = scanner.next().charAt(0);

        double result = 0;

        switch (operator) {
            case '+':
                result = num1 + num2;
                break;
            case '-':
                result = num1 - num2;
                break;
            case '*':
                result = num1 * num2;
                break;
            case '/':
                if (num2 != 0) {
                    result = num1 / num2;
                } else {
                    System.out.println("Error: Division by zero");
                    return;
                }
                break;
            default:
                System.out.println("Error: Invalid operator");
                return;
        }

        System.out.println("The result is: " + result);
    }
}

概念應用: 使用了數據類型（double）、運算符（+, , , /）、switch 控制結構。
具體來說：這在需要用戶輸入單個字符時特別有用，例如在本例中，用戶輸入操作符（+, -, *, /）。
- scanner.next() 會讀取用戶輸入的下一個完整字符串。
- charAt(0) 會提取該字符串的第一個字符（索引為0）。

練習題 2: 判斷整數的奇偶性

任務: 輸入一個整數，判斷該整數是奇數還是偶數。

import java.util.Scanner;

public class OddEvenChecker {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("Enter an integer:");
        int number = scanner.nextInt();

        if (number % 2 == 0) {
            System.out.println(number + " is even.");
        } else {
            System.out.println(number + " is odd.");
        }
    }
}

概念應用: 使用了數據類型（int）、運算符（%）、if-else 控制結構。

練習題 3: 計算1到10的總和

任務: 使用 for 迴圈計算並輸出1到10的整數總和。

public class SumOfNumbers {
    public static void main(String[] args) {
        int sum = 0;

        for (int i = 1; i <= 10; i++) {
            sum += i;
        }

        System.out.println("Sum of numbers from 1 to 10 is: " + sum);
    }
}

概念應用: 使用了數據類型（int）、賦值運算符（+=）、for 迴圈。

練習題 4: 反轉整數數組

任務: 使用 while 迴圈反轉一個整數數組的順序。

public class ReverseArray {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        int left = 0, right = numbers.length - 1;

        while (left < right) {
            // 交換元素
            int temp = numbers[left];
            numbers[left] = numbers[right];
            numbers[right] = temp;

            left++;
            right--;
        }

        // 輸出反轉後的數組
        for (int num : numbers) {
            System.out.print(num + " ");
        }
    }
}

概念應用: 使用了數據類型（int）、while 迴圈、陣列操作。

練習題 5: 計算數字的階乘

任務: 使用 do-while 迴圈計算一個正整數的階乘。

import java.util.Scanner;

public class FactorialCalculator {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("Enter a positive integer:");
        int number = scanner.nextInt();

        int factorial = 1;
        int i = 1;

        do {
            factorial *= i;
            i++;
        } while (i <= number);

        System.out.println("Factorial of " + number + " is: " + factorial);
    }
}

概念應用: 使用了數據類型（int）、運算符（``）、do-while 迴圈。
為了解決這個問題，可以使用long類型來存儲更大的數值，甚至可以使用BigInteger類型來存儲更大的數值而不會溢出。以下是使用BigInteger的範例：這樣就可以正確計算大數的階乘而不會溢出。

練習題 6: 最大公因數（GCD）

任務: 使用 if 和 while 迴圈計算兩個整數的最大公因數。

import java.util.Scanner;

public class GCDCalculator {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("Enter first integer:");
        int num1 = scanner.nextInt();

        System.out.println("Enter second integer:");
        int num2 = scanner.nextInt();

        while (num1 != num2) {
            if (num1 > num2) {
                num1 -= num2;
            } else {
                num2 -= num1;
            }
        }

        System.out.println("GCD is: " + num1);
    }
}

概念應用: 使用了數據類型（int）、if 控制結構、while 迴圈。

這樣做的原因是為了計算兩個數字的最大公因數（GCD）。這是一種基於歐幾里得算法的迭代方法。具體步驟如下：

比較兩個數字大小：如果 num1 大於 num2，則將 num1 減去 num2。
更新變量值：這樣做的目的是將較大的數字減小，直到兩個數字相等。
繼續迭代：如果 num1 不大於 num2，則將 num2 減去 num1。這樣的迭代過程會不斷縮小兩個數字的差距。
結束條件：當 num1 等於 num2 時，兩者的值即為最大公因數。

這種方法的核心在於，每次迭代都將較大的數字減小，直到兩個數字相等。這個相等的數字就是這兩個數字的最大公因數。

Java學習：第1週-Java基礎知識

一、 數據類型和變量宣告（閱讀和實踐）

1. 基本數據類型（Primitive Data Types）

2. 變量宣告（Variable Declaration）

例子

3. 變量的作用域（Scope of Variables）

4. 常量（Constants）

5. 實踐練習

練習 1: 宣告並初始化各種類型的變量

練習 2: 嘗試更改常量的值並觀察錯誤

二、運算符和表達式

1. 運算符概述

2. 各類運算符的詳細介紹

2.1 算術運算符（Arithmetic Operators）

2.2 關係運算符（Relational Operators）

2.3 邏輯運算符（Logical Operators）

2.4 位元運算符（Bitwise Operators）

2.5 賦值運算符（Assignment Operators）

2.6 增量與減量運算符（Increment/Decrement Operators）

2.7 條件運算符（三元運算符 Ternary Operator）

3. 實踐練習

練習 1: 算術運算符

練習 2: 關係和邏輯運算符

練習 3: 賦值運算符和增量/減量運算符

練習 4: 三元運算符

三、控制結構（if, switch）

1. if 控制結構

1.1 基本語法

1.2 if-else 語法

1.3 if-else if-else 語法

1.4 範例

2. switch 控制結構

2.1 基本語法

2.2 範例

3. if 和 switch 的區別

4. 實踐練習

練習 1: 使用 if-else 控制結構

練習 2: 使用 switch 控制結構

為何在 switch 中使用 break 而不是 return

四、控制結構（for, while, do-while）

1. for 迴圈

1.1 基本語法

1.2 範例

2. while 迴圈

2.1 基本語法

2.2 範例

3. do-while 迴圈

3.1 基本語法

3.2 範例

do-while 循環與 while 循環的主要區別在於執行條件的檢查時間點：

4. 迴圈中的控制語句

4.1 範例：break 和 continue

5. 實踐練習

練習 1: 使用 for 迴圈

練習 2: 使用 while 迴圈

練習 3: 使用 do-while 迴圈

五、基礎練習題

基礎練習題概述

練習題 1: 基本計算器

練習題 2: 判斷整數的奇偶性

練習題 3: 計算1到10的總和

練習題 4: 反轉整數數組

練習題 5: 計算數字的階乘

練習題 6: 最大公因數（GCD）

一、數據類型和變量宣告（閱讀和實踐）

1. `if` 控制結構

1.2 `if-else` 語法

1.3 `if-else if-else` 語法

2. `switch` 控制結構

3. `if` 和 `switch` 的區別

練習 1: 使用 `if-else` 控制結構

練習 2: 使用 `switch` 控制結構

1. `for` 迴圈

2. `while` 迴圈

3. `do-while` 迴圈

`do-while` 循環與 `while` 循環的主要區別在於執行條件的檢查時間點：

4.1 範例：`break` 和 `continue`

練習 1: 使用 `for` 迴圈

練習 2: 使用 `while` 迴圈

練習 3: 使用 `do-while` 迴圈