Java运算符与流程控制之全类型运算符用法及分支 / 循环语句实战指南

public class ArithmeticBasicDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 3;
        
        // 加法运算
        int addResult = a + b;
        System.out.println("a + b = " + addResult); // 输出13
        
        // 减法运算
        int subResult = a - b;
        System.out.println("a - b = " + subResult); // 输出7
        
        // 乘法运算
        int mulResult = a * b;
        System.out.println("a * b = " + mulResult); // 输出30
        
        // 除法运算：整数相除结果为整数，舍弃小数部分
        int divResult1 = a / b;
        System.out.println("a / b（整数相除） = " + divResult1); // 输出3
        
        // 除法运算：浮点数相除结果为浮点数
        double divResult2 = (double) a / b;
        System.out.println("a / b（浮点数相除） = " + divResult2); // 输出3.3333333333333335
        
        // 取模运算：返回除法的余数，符号与被除数一致
        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，再参与其他运算
        int preIncrement = ++x;
        System.out.println("前置自增后x = " + x); // 输出6
        System.out.println("前置自增结果 = " + preIncrement); // 输出6
        
        // 后置自增：先参与其他运算，再自增1
        int postIncrement = y++;
        System.out.println("后置自增后y = " + y); // 输出6
        System.out.println("后置自增结果 = " + postIncrement); // 输出5
        
        int m = 3;
        int n = 3;
        
        // 前置自减：先自减1，再参与其他运算
        int preDecrement = --m;
        System.out.println("前置自减后m = " + m); // 输出2
        System.out.println("前置自减结果 = " + preDecrement); // 输出2
        
        // 后置自减：先参与其他运算，再自减1
        int postDecrement = n--;
        System.out.println("后置自减后n = " + n); // 输出2
        System.out.println("后置自减结果 = " + 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");
        
        // 数值类型的关系判断
        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
        
        // 引用类型的关系判断：== 比较的是对象地址，equals() 比较的是内容
        System.out.println("s1 == s2 : " + (s1 == s2)); // 输出true（字符串常量池，地址相同）
        System.out.println("s1 == s3 : " + (s1 == s3)); // 输出false（堆内存中不同对象，地址不同）
        System.out.println("s1.equals(s3) : " + s1.equals(s3)); // 输出true（内容相同）
    }
}

public class LogicalOperatorDemo {
    public static void main(String[] args) {
        int num = 15;
        
        // 短路与：num > 10 为true，继续判断num < 20，最终为true
        boolean shortAnd = (num > 10) && (num < 20);
        System.out.println("短路与结果：" + shortAnd); // 输出true
        
        // 短路与：num < 10 为false，直接返回false，不执行num++
        int temp1 = num;
        boolean shortAnd2 = (temp1 < 10) && (temp1++ > 0);
        System.out.println("短路与2结果：" + shortAnd2); // 输出false
        System.out.println("temp1的值：" + temp1); // 输出15（temp1++未执行）
        
        // 逻辑与：temp1 < 10 为false，仍会执行temp1++
        int temp2 = num;
        boolean logicAnd = (temp2 < 10) & (temp2++ > 0);
        System.out.println("逻辑与结果：" + logicAnd); // 输出false
        System.out.println("temp2的值：" + temp2); // 输出16（temp2++已执行）
        
        // 短路或：num > 10 为true，直接返回true，不执行num--
        int temp3 = num;
        boolean shortOr = (temp3 > 10) || (temp3-- < 0);
        System.out.println("短路或结果：" + shortOr); // 输出true
        System.out.println("temp3的值：" + temp3); // 输出15（temp3--未执行）
        
        // 逻辑或：num > 10 为true，仍会执行num--
        int temp4 = num;
        boolean logicOr = (temp4 > 10) | (temp4-- < 0);
        System.out.println("逻辑或结果：" + logicOr); // 输出true
        System.out.println("temp4的值：" + temp4); // 输出14（temp4--已执行）
        
        // 逻辑非
        boolean flag = true;
        boolean notFlag = !flag;
        System.out.println("!true = " + notFlag); // 输出false
        System.out.println("!false = " + !notFlag); // 输出true
        
        // 复杂逻辑组合
        boolean complexCondition = (num > 0) && (num % 2 == 1) || (num == 0);
        System.out.println("复杂条件结果：" + complexCondition); // 输出true（15>0且是奇数）
    }
}

int a = 10; // 基本赋值
String name = "Java语法"; // 基本赋值
a = a + 5; // 将a+5的结果赋值给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
        
        // 复合赋值运算符会自动进行类型转换
        byte b = 5;
        b += 3; // 等价于 b = (byte)(b + 3)，自动强制类型转换
        System.out.println("byte类型b += 3 后：" + b); // 输出8
        
        // 以下代码编译报错：直接赋值不会自动类型转换
        // 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 ? "优秀" : (score >= 80 ? "良好" : (score >= 60 ? "及格" : "不及格"));
        System.out.println("成绩等级：" + grade); // 输出良好
        
        // 获取两个数的最大值
        int maxNum = num1 > num2 ? num1 : num2;
        System.out.println("最大值：" + maxNum); // 输出30
        
        // 获取三个数的最小值
        int num3 = 15;
        int minNum = (num1 < num2 ? num1 : num2) < num3 ? (num1 < num2 ? num1 : num2) : num3;
        System.out.println("最小值：" + minNum); // 输出15
        
        // 自动类型转换：表达式1和表达式2类型不同，自动转为范围更大的类型
        double result = num1 > 25 ? 10 : 3.14;
        System.out.println("自动类型转换结果：" + result); // 输出3.14
    }
}

public class OperatorPriorityDemo {
    public static void main(String[] args) {
        int a = 2;
        int b = 3;
        int c = 4;
        
        // 优先级：括号 > 乘除 > 加减
        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）
        
        // 优先级：自增 > 算术运算 > 关系运算 > 逻辑运算
        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
        
        // 结合性：赋值运算符从右到左
        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
        
        // 结合性：算术运算符从左到右
        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（强制转换，可能溢出）
        int a = 200;
        byte b = (byte) a;
        System.out.println(b); // 输出-56（200超出byte的取值范围，发生溢出）
        
        // double → int（强制转换，精度丢失）
        double d = 3.99;
        int num = (int) d;
        System.out.println(num); // 输出3（小数部分被舍弃，不是四舍五入）
        
        // long → int（强制转换，可能溢出）
        long l = 10000000000L;
        int i = (int) l;
        System.out.println(i); // 输出1410065408（超出int范围，溢出）
        
        // 补充：浮点型转浮点型（精度丢失）
        double bigDouble = 123456789.123456789;
        float smallFloat = (float) bigDouble;
        System.out.println(smallFloat); // 输出1.23456792E8（精度丢失，有效数字不足）
    }
}

if (条件表达式) {
    // 条件为true时执行的代码块
}

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("恭喜你，成绩达到优秀等级！");
            System.out.println("获得奖学金奖励。");
        }
        System.out.println("单分支判断结束。");
    }
}

if (条件表达式) {
    // 条件为true时执行的代码块
} else {
    // 条件为false时执行的代码块
}

public class IfElseDemo {
    public static void main(String[] args) {
        int num = -7;
        
        // 双分支判断：正数/非正数
        if (num > 0) {
            System.out.println(num + " 是正数。");
        } else {
            System.out.println(num + " 是负数或零。");
        }
        
        String gender = "女";
        if (gender.equals("男")) {
            System.out.println("性别：男");
        } else {
            System.out.println("性别：女");
        }
    }
}

if (条件表达式1) {
    // 条件1为true时执行的代码块
} else if (条件表达式2) {
    // 条件1为false、条件2为true时执行的代码块
} else if (条件表达式3) {
    // 条件1、2为false、条件3为true时执行的代码块
} else {
    // 所有条件都为false时执行的代码块
}

public class IfElseIfDemo {
    public static void main(String[] args) {
        int score = 75;
        String grade;
        
        // 多分支判断成绩等级
        if (score >= 90 && score <= 100) {
            grade = "优秀";
        } 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); // 输出中等
        
        // 多分支判断季节
        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 (表达式) {
    case 常量值1:
        // 表达式等于常量值1时执行的代码块
        break; // 跳出switch语句
    case 常量值2:
        // 表达式等于常量值2时执行的代码块
        break;
    // 更多case语句
    default:
        // 表达式不等于任何常量值时执行的代码块
        break;
}

public class SwitchBasicDemo {
    public static void main(String[] args) {
        // 整数类型的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 = "无效的星期数";
                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) {
        // 利用穿透现象判断工作日/休息日
        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("无效的星期数。");
                break;
        }
        
        // 未添加break的穿透现象（慎用）
        int num = 2;
        switch (num) {
            case 1:
                System.out.println("执行case 1");
            case 2:
                System.out.println("执行case 2");
            case 3:
                System.out.println("执行case 3");
            default:
                System.out.println("执行default");
        }
        // 输出：执行case 2、执行case 3、执行default（穿透执行）
    }
}

for (初始化表达式; 条件表达式; 更新表达式) {
    // 循环体：条件表达式为true时重复执行的代码块
}

public class ForBasicDemo {
    public static void main(String[] args) {
        // 示例1：循环输出1-5的数字
        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：循环输出数组元素
        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的数字
        for (int k = 10; k >= 1; k--) {
            System.out.println("k = " + k);
        }
    }
}

for (元素类型 变量名 : 数组/集合) {
    // 循环体：变量名表示当前遍历到的元素
}

public class ForEachDemo {
    public static void main(String[] args) {
        // 遍历数组
        int[] arr = {1, 3, 5, 7, 9};
        System.out.println("数组元素：");
        for (int element : arr) {
            System.out.print(element + " ");
        }
        System.out.println(); // 输出1 3 5 7 9
        
        // 遍历字符串数组
        String[] names = {"张三", "李四", "王五", "赵六"};
        System.out.println("姓名列表：");
        for (String name : names) {
            System.out.println(name);
        }
        
        // 增强for循环的限制：无法修改数组元素的值（仅获取元素）
        for (int num : arr) {
            num *= 2; // 仅修改局部变量num，不会改变数组原元素
        }
        System.out.println("修改后数组元素：");
        for (int element : arr) {
            System.out.print(element + " ");
        } // 仍输出1 3 5 7 9
    }
}

public class ForSpecialDemo {
    public static void main(String[] args) {
        // 多个循环变量的for循环
        for (int i = 0, j = 10; i <= 10 && j >= 0; i++, j--) {
            System.out.println("i = " + i + ", j = " + j);
        }
        
        // 省略初始化表达式（循环变量已提前声明）
        int k = 1;
        for (; k <= 5; k++) {
            System.out.println("k = " + k);
        }
        
        // 省略更新表达式（在循环体内更新）
        int m = 1;
        for (; m <= 5; ) {
            System.out.println("m = " + m);
            m++; // 手动更新循环变量
        }
        
        // 无限循环（需在循环体内添加退出条件）
        int n = 1;
        for (;;) {
            System.out.println("无限循环：n = " + n);
            n++;
            if (n > 3) {
                break; // 退出无限循环
            }
        }
    }
}

初始化表达式;
while (条件表达式) {
    // 循环体
    更新表达式;
}

public class WhileBasicDemo {
    public static void main(String[] args) {
        // 示例1：循环输出1-5的数字
        int i = 1;
        while (i <= 5) {
            System.out.println("i = " + i);
            i++; // 更新循环变量
        }
        
        // 示例2：计算1-100的偶数和
        int sumEven = 0;
        int num = 1;
        while (num <= 100) {
            if (num % 2 == 0) {
                sumEven += num;
            }
            num++;
        }
        System.out.println("1-100的偶数和：" + sumEven); // 输出2550
        
        // 示例3：未知次数循环（猜数字游戏）
        int randomNum = (int) (Math.random() * 100) + 1; // 生成1-100的随机数
        int guessNum = 0;
        java.util.Scanner scanner = new java.util.Scanner(System.in);
        
        while (guessNum != randomNum) {
            System.out.print("请输入你猜测的数字（1-100）：");
            guessNum = scanner.nextInt();
            if (guessNum > randomNum) {
                System.out.println("猜大了，请继续猜测！");
            } else if (guessNum < randomNum) {
                System.out.println("猜小了，请继续猜测！");
            } else {
                System.out.println("恭喜你，猜对了！");
            }
        }
        scanner.close();
    }
}

初始化表达式;
do {
    // 循环体
    更新表达式;
} while (条件表达式);

public class DoWhileDemo {
    public static void main(String[] args) {
        // 示例1：循环输出1-5的数字
        int i = 1;
        do {
            System.out.println("i = " + i);
            i++;
        } while (i <= 5);
        
        // 示例2：条件不满足时，循环体仍执行一次
        int j = 6;
        do {
            System.out.println("j = " + j); // 会输出j=6
            j++;
        } while (j <= 5);
        
        // 示例3：用户输入验证（确保至少输入一次）
        java.util.Scanner scanner = new java.util.Scanner(System.in);
        String password;
        do {
            System.out.print("请输入密码（6位数字）：");
            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循环
        for (int i = 1; i <= 10; i++) {
            if (i == 6) {
                break; // 当i=6时，跳出循环
            }
            System.out.println("i = " + i); // 输出1-5
        }
        
        // 跳出单层while循环
        int j = 1;
        while (j <= 10) {
            if (j == 6) {
                break;
            }
            System.out.println("j = " + j); // 输出1-5
            j++;
        }
        
        // 跳出多层循环（使用标签）
        outer: // 外层循环标签
        for (int m = 1; m <= 3; m++) {
            inner: // 内层循环标签
            for (int n = 1; n <= 3; n++) {
                if (m == 2 && n == 2) {
                    break outer; // 跳出外层循环
                }
                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) {
        // 跳过当前for循环（输出1-10的奇数）
        for (int i = 1; i <= 10; i++) {
            if (i % 2 == 0) {
                continue; // 跳过偶数，直接进入下一次循环
            }
            System.out.println("奇数：" + i); // 输出1、3、5、7、9
        }
        
        // 跳过当前while循环
        int j = 0;
        while (j < 10) {
            j++;
            if (j % 2 == 0) {
                continue;
            }
            System.out.println("奇数：" + j); // 输出1、3、5、7、9
        }
        
        // 跳过内层循环（使用标签）
        outer:
        for (int m = 1; m <= 3; m++) {
            for (int n = 1; n <= 3; n++) {
                if (n == 2) {
                    continue outer; // 跳过内层循环剩余部分，进入外层循环下一次迭代
                }
                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++) { // 外层循环：控制行数
            for (int j = 1; j <= i; j++) { // 内层循环：控制每行的列数
                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：遍历二维数组
        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();
        }
    }
}