public class ArithmeticBasicDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 3;
        
        // 加法運(yùn)算
        int addResult = a + b;
        System.out.println("a + b = " + addResult); // 輸出13
        
        // 減法運(yùn)算
        int subResult = a - b;
        System.out.println("a - b = " + subResult); // 輸出7
        
        // 乘法運(yùn)算
        int mulResult = a * b;
        System.out.println("a * b = " + mulResult); // 輸出30
        
        // 除法運(yùn)算：整數(shù)相除結(jié)果為整數(shù)，舍棄小數(shù)部分
        int divResult1 = a / b;
        System.out.println("a / b（整數(shù)相除） = " + divResult1); // 輸出3
        
        // 除法運(yùn)算：浮點(diǎn)數(shù)相除結(jié)果為浮點(diǎn)數(shù)
        double divResult2 = (double) a / b;
        System.out.println("a / b（浮點(diǎn)數(shù)相除） = " + divResult2); // 輸出3.3333333333333335
        
        // 取模運(yùn)算：返回除法的余數(shù)，符號與被除數(shù)一致
        int modResult1 = a % b;
        System.out.println("a % b = " + modResult1); // 輸出1
        
        int modResult2 = -10 % 3;
        System.out.println("-10 % 3 = " + modResult2); // 輸出-1
        
        int modResult3 = 10 % -3;
        System.out.println("10 % -3 = " + modResult3); // 輸出1
    }
}

public class ArithmeticExtendDemo {
    public static void main(String[] args) {
        int x = 5;
        int y = 5;
        
        // 前置自增：先自增1，再參與其他運(yùn)算
        int preIncrement = ++x;
        System.out.println("前置自增后x = " + x); // 輸出6
        System.out.println("前置自增結(jié)果 = " + preIncrement); // 輸出6
        
        // 后置自增：先參與其他運(yùn)算，再自增1
        int postIncrement = y++;
        System.out.println("后置自增后y = " + y); // 輸出6
        System.out.println("后置自增結(jié)果 = " + postIncrement); // 輸出5
        
        int m = 3;
        int n = 3;
        
        // 前置自減：先自減1，再參與其他運(yùn)算
        int preDecrement = --m;
        System.out.println("前置自減后m = " + m); // 輸出2
        System.out.println("前置自減結(jié)果 = " + preDecrement); // 輸出2
        
        // 后置自減：先參與其他運(yùn)算，再自減1
        int postDecrement = n--;
        System.out.println("后置自減后n = " + n); // 輸出2
        System.out.println("后置自減結(jié)果 = " + postDecrement); // 輸出3
    }
}

public class RelationalOperatorDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        String s1 = "Java";
        String s2 = "Java";
        String s3 = new String("Java");
        
        // 數(shù)值類型的關(guān)系判斷
        System.out.println("a > b : " + (a > b)); // 輸出false
        System.out.println("a < b : " + (a < b)); // 輸出true
        System.out.println("a >= 10 : " + (a >= 10)); // 輸出true
        System.out.println("b <= 19 : " + (b <= 19)); // 輸出false
        System.out.println("a == 10 : " + (a == 10)); // 輸出true
        System.out.println("a != b : " + (a != b)); // 輸出true
        
        // 引用類型的關(guān)系判斷：== 比較的是對象地址，equals() 比較的是內(nèi)容
        System.out.println("s1 == s2 : " + (s1 == s2)); // 輸出true（字符串常量池，地址相同）
        System.out.println("s1 == s3 : " + (s1 == s3)); // 輸出false（堆內(nèi)存中不同對象，地址不同）
        System.out.println("s1.equals(s3) : " + s1.equals(s3)); // 輸出true（內(nèi)容相同）
    }
}

public class LogicalOperatorDemo {
    public static void main(String[] args) {
        int num = 15;
        
        // 短路與：num > 10 為true，繼續(xù)判斷num < 20，最終為true
        boolean shortAnd = (num > 10) && (num < 20);
        System.out.println("短路與結(jié)果：" + shortAnd); // 輸出true
        
        // 短路與：num < 10 為false，直接返回false，不執(zhí)行num++
        int temp1 = num;
        boolean shortAnd2 = (temp1 < 10) && (temp1++ > 0);
        System.out.println("短路與2結(jié)果：" + shortAnd2); // 輸出false
        System.out.println("temp1的值：" + temp1); // 輸出15（temp1++未執(zhí)行）
        
        // 邏輯與：temp1 < 10 為false，仍會執(zhí)行temp1++
        int temp2 = num;
        boolean logicAnd = (temp2 < 10) & (temp2++ > 0);
        System.out.println("邏輯與結(jié)果：" + logicAnd); // 輸出false
        System.out.println("temp2的值：" + temp2); // 輸出16（temp2++已執(zhí)行）
        
        // 短路或：num > 10 為true，直接返回true，不執(zhí)行num--
        int temp3 = num;
        boolean shortOr = (temp3 > 10) || (temp3-- < 0);
        System.out.println("短路或結(jié)果：" + shortOr); // 輸出true
        System.out.println("temp3的值：" + temp3); // 輸出15（temp3--未執(zhí)行）
        
        // 邏輯或：num > 10 為true，仍會執(zhí)行num--
        int temp4 = num;
        boolean logicOr = (temp4 > 10) | (temp4-- < 0);
        System.out.println("邏輯或結(jié)果：" + logicOr); // 輸出true
        System.out.println("temp4的值：" + temp4); // 輸出14（temp4--已執(zhí)行）
        
        // 邏輯非
        boolean flag = true;
        boolean notFlag = !flag;
        System.out.println("!true = " + notFlag); // 輸出false
        System.out.println("!false = " + !notFlag); // 輸出true
        
        // 復(fù)雜邏輯組合
        boolean complexCondition = (num > 0) && (num % 2 == 1) || (num == 0);
        System.out.println("復(fù)雜條件結(jié)果：" + complexCondition); // 輸出true（15>0且是奇數(shù)）
    }
}

int a = 10; // 基本賦值
String name = "Java語法"; // 基本賦值
a = a + 5; // 將a+5的結(jié)果賦值給a

public class AssignmentOperatorDemo {
    public static void main(String[] args) {
        int a = 10;
        
        // += 等價于 a = a + 5
        a += 5;
        System.out.println("a += 5 后：" + a); // 輸出15
        
        // -= 等價于 a = a - 3
        a -= 3;
        System.out.println("a -= 3 后：" + a); // 輸出12
        
        // *= 等價于 a = a * 2
        a *= 2;
        System.out.println("a *= 2 后：" + a); // 輸出24
        
        // /= 等價于 a = a / 4
        a /= 4;
        System.out.println("a /= 4 后：" + a); // 輸出6
        
        // %= 等價于 a = a % 4
        a %= 4;
        System.out.println("a %= 4 后：" + a); // 輸出2
        
        // 復(fù)合賦值運(yùn)算符會自動進(jìn)行類型轉(zhuǎn)換
        byte b = 5;
        b += 3; // 等價于 b = (byte)(b + 3)，自動強(qiáng)制類型轉(zhuǎn)換
        System.out.println("byte類型b += 3 后：" + b); // 輸出8
        
        // 以下代碼編譯報錯：直接賦值不會自動類型轉(zhuǎn)換
        // byte c = 5;
        // c = c + 3; // 錯誤：int類型無法賦值給byte類型
    }
}

public class TernaryOperatorDemo {
    public static void main(String[] args) {
        int score = 85;
        int num1 = 20;
        int num2 = 30;
        
        // 判斷成績等級
        String grade = score >= 90 ? "優(yōu)秀" : (score >= 80 ? "良好" : (score >= 60 ? "及格" : "不及格"));
        System.out.println("成績等級：" + grade); // 輸出良好
        
        // 獲取兩個數(shù)的最大值
        int maxNum = num1 > num2 ? num1 : num2;
        System.out.println("最大值：" + maxNum); // 輸出30
        
        // 獲取三個數(shù)的最小值
        int num3 = 15;
        int minNum = (num1 < num2 ? num1 : num2) < num3 ? (num1 < num2 ? num1 : num2) : num3;
        System.out.println("最小值：" + minNum); // 輸出15
        
        // 自動類型轉(zhuǎn)換：表達(dá)式1和表達(dá)式2類型不同，自動轉(zhuǎn)為范圍更大的類型
        double result = num1 > 25 ? 10 : 3.14;
        System.out.println("自動類型轉(zhuǎn)換結(jié)果：" + result); // 輸出3.14
    }
}

public class OperatorPriorityDemo {
    public static void main(String[] args) {
        int a = 2;
        int b = 3;
        int c = 4;
        
        // 優(yōu)先級：括號 > 乘除 > 加減
        int result1 = a + b * c;
        System.out.println("a + b * c = " + result1); // 輸出14（先算3*4=12，再算2+12=14）
        int result2 = (a + b) * c;
        System.out.println("(a + b) * c = " + result2); // 輸出20（先算2+3=5，再算5*4=20）
        
        // 優(yōu)先級：自增 > 算術(shù)運(yùn)算 > 關(guān)系運(yùn)算 > 邏輯運(yùn)算
        int x = 5;
        boolean result3 = x++ > 5 && x < 8;
        System.out.println("x++ > 5 && x < 8 = " + result3); // 輸出false（x++=5，5>5為false，短路與直接返回false）
        System.out.println("x的值：" + x); // 輸出6
        
        // 結(jié)合性：賦值運(yùn)算符從右到左
        int m = 1;
        int n = 2;
        int p = 3;
        m = n = p; // 等價于m = (n = p)
        System.out.println("m = " + m + ", n = " + n + ", p = " + p); // 輸出m=3, n=3, p=3
        
        // 結(jié)合性：算術(shù)運(yùn)算符從左到右
        int result4 = a + b + c;
        System.out.println("a + b + c = " + result4); // 輸出9（先算2+3=5，再算5+4=9）
    }
}

public class ForceTypeConvertDemo {
    public static void main(String[] args) {
        // int → byte（強(qiáng)制轉(zhuǎn)換，可能溢出）
        int a = 200;
        byte b = (byte) a;
        System.out.println(b); // 輸出-56（200超出byte的取值范圍，發(fā)生溢出）
        
        // double → int（強(qiáng)制轉(zhuǎn)換，精度丟失）
        double d = 3.99;
        int num = (int) d;
        System.out.println(num); // 輸出3（小數(shù)部分被舍棄，不是四舍五入）
        
        // long → int（強(qiáng)制轉(zhuǎn)換，可能溢出）
        long l = 10000000000L;
        int i = (int) l;
        System.out.println(i); // 輸出1410065408（超出int范圍，溢出）
        
        // 補(bǔ)充：浮點(diǎn)型轉(zhuǎn)浮點(diǎn)型（精度丟失）
        double bigDouble = 123456789.123456789;
        float smallFloat = (float) bigDouble;
        System.out.println(smallFloat); // 輸出1.23456792E8（精度丟失，有效數(shù)字不足）
    }
}

if (條件表達(dá)式) {
    // 條件為true時執(zhí)行的代碼塊
}

public class IfSingleDemo {
    public static void main(String[] args) {
        int age = 18;
        
        // 單分支判斷：是否成年
        if (age >= 18) {
            System.out.println("你已成年，具備完全民事行為能力。");
        }
        
        int score = 95;
        if (score >= 90) {
            System.out.println("恭喜你，成績達(dá)到優(yōu)秀等級！");
            System.out.println("獲得獎學(xué)金獎勵。");
        }
        System.out.println("單分支判斷結(jié)束。");
    }
}

if (條件表達(dá)式) {
    // 條件為true時執(zhí)行的代碼塊
} else {
    // 條件為false時執(zhí)行的代碼塊
}

public class IfElseDemo {
    public static void main(String[] args) {
        int num = -7;
        
        // 雙分支判斷：正數(shù)/非正數(shù)
        if (num > 0) {
            System.out.println(num + " 是正數(shù)。");
        } else {
            System.out.println(num + " 是負(fù)數(shù)或零。");
        }
        
        String gender = "女";
        if (gender.equals("男")) {
            System.out.println("性別：男");
        } else {
            System.out.println("性別：女");
        }
    }
}

if (條件表達(dá)式1) {
    // 條件1為true時執(zhí)行的代碼塊
} else if (條件表達(dá)式2) {
    // 條件1為false、條件2為true時執(zhí)行的代碼塊
} else if (條件表達(dá)式3) {
    // 條件1、2為false、條件3為true時執(zhí)行的代碼塊
} else {
    // 所有條件都為false時執(zhí)行的代碼塊
}

public class IfElseIfDemo {
    public static void main(String[] args) {
        int score = 75;
        String grade;
        
        // 多分支判斷成績等級
        if (score >= 90 && score <= 100) {
            grade = "優(yōu)秀";
        } else if (score >= 80 && score < 90) {
            grade = "良好";
        } else if (score >= 70 && score < 80) {
            grade = "中等";
        } else if (score >= 60 && score < 70) {
            grade = "及格";
        } else if (score >= 0 && score < 60) {
            grade = "不及格";
        } else {
            grade = "無效成績";
        }
        
        System.out.println("你的成績等級是：" + grade); // 輸出中等
        
        // 多分支判斷季節(jié)
        int month = 10;
        if (month >= 3 && month <= 5) {
            System.out.println(month + "月屬于春季。");
        } else if (month >= 6 && month <= 8) {
            System.out.println(month + "月屬于夏季。");
        } else if (month >= 9 && month <= 11) {
            System.out.println(month + "月屬于秋季。");
        } else if (month == 12 || month >= 1 && month <= 2) {
            System.out.println(month + "月屬于冬季。");
        } else {
            System.out.println(month + "月是無效月份。");
        }
    }
}

switch (表達(dá)式) {
    case 常量值1:
        // 表達(dá)式等于常量值1時執(zhí)行的代碼塊
        break; // 跳出switch語句
    case 常量值2:
        // 表達(dá)式等于常量值2時執(zhí)行的代碼塊
        break;
    // 更多case語句
    default:
        // 表達(dá)式不等于任何常量值時執(zhí)行的代碼塊
        break;
}

public class SwitchBasicDemo {
    public static void main(String[] args) {
        // 整數(shù)類型的switch判斷
        int week = 3;
        String weekName;
        switch (week) {
            case 1:
                weekName = "星期一";
                break;
            case 2:
                weekName = "星期二";
                break;
            case 3:
                weekName = "星期三";
                break;
            case 4:
                weekName = "星期四";
                break;
            case 5:
                weekName = "星期五";
                break;
            case 6:
                weekName = "星期六";
                break;
            case 7:
                weekName = "星期日";
                break;
            default:
                weekName = "無效的星期數(shù)";
                break;
        }
        System.out.println("今天是：" + weekName); // 輸出星期三
        
        // 字符串類型的switch判斷（JDK7+）
        String fruit = "蘋果";
        switch (fruit) {
            case "蘋果":
                System.out.println("蘋果的單價是5元/斤。");
                break;
            case "香蕉":
                System.out.println("香蕉的單價是3元/斤。");
                break;
            case "橙子":
                System.out.println("橙子的單價是4元/斤。");
                break;
            default:
                System.out.println("暫無該水果的價格信息。");
                break;
        }
    }
}

public class SwitchPenetrationDemo {
    public static void main(String[] args) {
        // 利用穿透現(xiàn)象判斷工作日/休息日
        int week = 6;
        switch (week) {
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
                System.out.println(week + "是工作日，需要上班。");
                break;
            case 6:
            case 7:
                System.out.println(week + "是休息日，可以休息。");
                break;
            default:
                System.out.println("無效的星期數(shù)。");
                break;
        }
        
        // 未添加break的穿透現(xiàn)象（慎用）
        int num = 2;
        switch (num) {
            case 1:
                System.out.println("執(zhí)行case 1");
            case 2:
                System.out.println("執(zhí)行case 2");
            case 3:
                System.out.println("執(zhí)行case 3");
            default:
                System.out.println("執(zhí)行default");
        }
        // 輸出：執(zhí)行case 2、執(zhí)行case 3、執(zhí)行default（穿透執(zhí)行）
    }
}

for (初始化表達(dá)式; 條件表達(dá)式; 更新表達(dá)式) {
    // 循環(huán)體：條件表達(dá)式為true時重復(fù)執(zhí)行的代碼塊
}

public class ForBasicDemo {
    public static void main(String[] args) {
        // 示例1：循環(huán)輸出1-5的數(shù)字
        for (int i = 1; i <= 5; i++) {
            System.out.println("i = " + i);
        }
        
        // 示例2：計算1-100的累加和
        int sum = 0;
        for (int num = 1; num <= 100; num++) {
            sum += num;
        }
        System.out.println("1-100的累加和：" + sum); // 輸出5050
        
        // 示例3：循環(huán)輸出數(shù)組元素
        int[] arr = {10, 20, 30, 40, 50};
        for (int j = 0; j < arr.length; j++) {
            System.out.println("arr[" + j + "] = " + arr[j]);
        }
        
        // 示例4：倒序輸出10-1的數(shù)字
        for (int k = 10; k >= 1; k--) {
            System.out.println("k = " + k);
        }
    }
}

for (元素類型 變量名 : 數(shù)組/集合) {
    // 循環(huán)體：變量名表示當(dāng)前遍歷到的元素
}

public class ForEachDemo {
    public static void main(String[] args) {
        // 遍歷數(shù)組
        int[] arr = {1, 3, 5, 7, 9};
        System.out.println("數(shù)組元素：");
        for (int element : arr) {
            System.out.print(element + " ");
        }
        System.out.println(); // 輸出1 3 5 7 9
        
        // 遍歷字符串?dāng)?shù)組
        String[] names = {"張三", "李四", "王五", "趙六"};
        System.out.println("姓名列表：");
        for (String name : names) {
            System.out.println(name);
        }
        
        // 增強(qiáng)for循環(huán)的限制：無法修改數(shù)組元素的值（僅獲取元素）
        for (int num : arr) {
            num *= 2; // 僅修改局部變量num，不會改變數(shù)組原元素
        }
        System.out.println("修改后數(shù)組元素：");
        for (int element : arr) {
            System.out.print(element + " ");
        } // 仍輸出1 3 5 7 9
    }
}

public class ForSpecialDemo {
    public static void main(String[] args) {
        // 多個循環(huán)變量的for循環(huán)
        for (int i = 0, j = 10; i <= 10 && j >= 0; i++, j--) {
            System.out.println("i = " + i + ", j = " + j);
        }
        
        // 省略初始化表達(dá)式（循環(huán)變量已提前聲明）
        int k = 1;
        for (; k <= 5; k++) {
            System.out.println("k = " + k);
        }
        
        // 省略更新表達(dá)式（在循環(huán)體內(nèi)更新）
        int m = 1;
        for (; m <= 5; ) {
            System.out.println("m = " + m);
            m++; // 手動更新循環(huán)變量
        }
        
        // 無限循環(huán)（需在循環(huán)體內(nèi)添加退出條件）
        int n = 1;
        for (;;) {
            System.out.println("無限循環(huán)：n = " + n);
            n++;
            if (n > 3) {
                break; // 退出無限循環(huán)
            }
        }
    }
}

初始化表達(dá)式;
while (條件表達(dá)式) {
    // 循環(huán)體
    更新表達(dá)式;
}

public class WhileBasicDemo {
    public static void main(String[] args) {
        // 示例1：循環(huán)輸出1-5的數(shù)字
        int i = 1;
        while (i <= 5) {
            System.out.println("i = " + i);
            i++; // 更新循環(huán)變量
        }
        
        // 示例2：計算1-100的偶數(shù)和
        int sumEven = 0;
        int num = 1;
        while (num <= 100) {
            if (num % 2 == 0) {
                sumEven += num;
            }
            num++;
        }
        System.out.println("1-100的偶數(shù)和：" + sumEven); // 輸出2550
        
        // 示例3：未知次數(shù)循環(huán)（猜數(shù)字游戲）
        int randomNum = (int) (Math.random() * 100) + 1; // 生成1-100的隨機(jī)數(shù)
        int guessNum = 0;
        java.util.Scanner scanner = new java.util.Scanner(System.in);
        
        while (guessNum != randomNum) {
            System.out.print("請輸入你猜測的數(shù)字（1-100）：");
            guessNum = scanner.nextInt();
            if (guessNum > randomNum) {
                System.out.println("猜大了，請繼續(xù)猜測！");
            } else if (guessNum < randomNum) {
                System.out.println("猜小了，請繼續(xù)猜測！");
            } else {
                System.out.println("恭喜你，猜對了！");
            }
        }
        scanner.close();
    }
}

初始化表達(dá)式;
do {
    // 循環(huán)體
    更新表達(dá)式;
} while (條件表達(dá)式);

public class DoWhileDemo {
    public static void main(String[] args) {
        // 示例1：循環(huán)輸出1-5的數(shù)字
        int i = 1;
        do {
            System.out.println("i = " + i);
            i++;
        } while (i <= 5);
        
        // 示例2：條件不滿足時，循環(huán)體仍執(zhí)行一次
        int j = 6;
        do {
            System.out.println("j = " + j); // 會輸出j=6
            j++;
        } while (j <= 5);
        
        // 示例3：用戶輸入驗(yàn)證（確保至少輸入一次）
        java.util.Scanner scanner = new java.util.Scanner(System.in);
        String password;
        do {
            System.out.print("請輸入密碼（6位數(shù)字）：");
            password = scanner.next();
        } while (password.length() != 6 || !password.matches("\\d+"));
        System.out.println("密碼輸入格式正確！");
        scanner.close();
    }
}

public class BreakDemo {
    public static void main(String[] args) {
        // 跳出單層for循環(huán)
        for (int i = 1; i <= 10; i++) {
            if (i == 6) {
                break; // 當(dāng)i=6時，跳出循環(huán)
            }
            System.out.println("i = " + i); // 輸出1-5
        }
        
        // 跳出單層while循環(huán)
        int j = 1;
        while (j <= 10) {
            if (j == 6) {
                break;
            }
            System.out.println("j = " + j); // 輸出1-5
            j++;
        }
        
        // 跳出多層循環(huán)（使用標(biāo)簽）
        outer: // 外層循環(huán)標(biāo)簽
        for (int m = 1; m <= 3; m++) {
            inner: // 內(nèi)層循環(huán)標(biāo)簽
            for (int n = 1; n <= 3; n++) {
                if (m == 2 && n == 2) {
                    break outer; // 跳出外層循環(huán)
                }
                System.out.println("m = " + m + ", n = " + n);
            }
        }
        // 輸出：m=1,n=1; m=1,n=2; m=1,n=3; m=2,n=1
    }
}

public class ContinueDemo {
    public static void main(String[] args) {
        // 跳過當(dāng)前for循環(huán)（輸出1-10的奇數(shù)）
        for (int i = 1; i <= 10; i++) {
            if (i % 2 == 0) {
                continue; // 跳過偶數(shù)，直接進(jìn)入下一次循環(huán)
            }
            System.out.println("奇數(shù)：" + i); // 輸出1、3、5、7、9
        }
        
        // 跳過當(dāng)前while循環(huán)
        int j = 0;
        while (j < 10) {
            j++;
            if (j % 2 == 0) {
                continue;
            }
            System.out.println("奇數(shù)：" + j); // 輸出1、3、5、7、9
        }
        
        // 跳過內(nèi)層循環(huán)（使用標(biāo)簽）
        outer:
        for (int m = 1; m <= 3; m++) {
            for (int n = 1; n <= 3; n++) {
                if (n == 2) {
                    continue outer; // 跳過內(nèi)層循環(huán)剩余部分，進(jìn)入外層循環(huán)下一次迭代
                }
                System.out.println("m = " + m + ", n = " + n);
            }
        }
        // 輸出：m=1,n=1; m=2,n=1; m=3,n=1
    }
}

public class LoopNestingDemo {
    public static void main(String[] args) {
        // 示例1：打印九九乘法表
        for (int i = 1; i <= 9; i++) { // 外層循環(huán)：控制行數(shù)
            for (int j = 1; j <= i; j++) { // 內(nèi)層循環(huán)：控制每行的列數(shù)
                System.out.print(j + "×" + i + "=" + (i * j) + "\t");
            }
            System.out.println(); // 換行
        }
        
        // 示例2：打印矩形（5行8列*）
        for (int row = 1; row <= 5; row++) {
            for (int col = 1; col <= 8; col++) {
                System.out.print("*");
            }
            System.out.println();
        }
        
        // 示例3：遍歷二維數(shù)組
        int[][] twoDArr = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        for (int i = 0; i < twoDArr.length; i++) {
            for (int j = 0; j < twoDArr[i].length; j++) {
                System.out.print(twoDArr[i][j] + " ");
            }
            System.out.println();
        }
    }
}