Java编程基础入门（四）---选择循环语句

一、Java中的运算符

（一）算术运算符

1. 核心运算符：包含+（加）、-（减）、*（乘）、/（除）、%（取模）、++（自增）、--（自减）。
2. 关键规则：整数除法结果为整数（如5/2=2）；取模结果符号与被模数一致（如-5%3=-2）；自增/自减前置先运算后赋值，后置先赋值后运算。
3. 编程案例：

public class ArithmeticDemo {
    public static void main(String[] args) {
        int a = 2;
        int b = 3;
        System.out.println("a+b=" + (a + b)); // 输出5
        System.out.println("a%b=" + (a % b)); // 输出2
        System.out.println("a++=" + (a++)); // 输出2，a变为3
        System.out.println("++a=" + (++a)); // 输出4，a变为4
    }
}

（二）赋值运算符

1. 核心运算符：基础赋值=，复合赋值+=、-=、*=、/=、%=。
2. 关键规则：复合赋值自动隐含强制类型转换；支持多变量链式赋值（如x=y=z=5），但不可直接int x=y=z=5。
3. 编程案例：

public class AssignmentDemo {
    public static void main(String[] args) {
        short s = 3;
        int i = 5;
        s += i; // 自动强制转换，等价于s=(short)(s+i)
        System.out.println("s=" + s); // 输出8
        int x = 10;
        x *= 2; // 等价于x=x*2
        System.out.println("x=" + x); // 输出20
    }
}

（三）比较运算符

1. 核心运算符：==（等于）、!=（不等于）、<（小于）、>（大于）、<=（小于等于）、>=（大于等于）。
2. 关键规则：结果为布尔值（true/false），切勿将==误写为赋值运算符=。
3. 编程案例：

public class ComparisonDemo {
    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 20;
        System.out.println(num1 == num2); // 输出false
        System.out.println(num1 < num2);  // 输出true
        System.out.println(num1 >= 5);    // 输出true
    }
}

（四）逻辑运算符

1. 核心运算符：&（与）、|（或）、!（非）、^（异或）、&&（短路与）、||（短路或）。
2. 关键规则：短路与左边为false时右边不执行，短路或左边为true时右边不执行，效率高于普通逻辑运算符。
3. 编程案例：

public class LogicDemo {
    public static void main(String[] args) {
        int x = 0, y = 0, z = 0;
        boolean a = x > 0 & y++ > 1; // 右边执行，y变为1
        boolean b = x > 0 && z++ > 1; // 右边不执行，z仍为0
        System.out.println("a=" + a + ", y=" + y); // 输出a=false, y=1
        System.out.println("b=" + b + ", z=" + z); // 输出b=false, z=0
    }
}

（五）运算符优先级

1. 核心规则：括号()优先级最高，算术运算>比较运算>逻辑运算>赋值运算。
2. 编程案例：

public class PriorityDemo {
    public static void main(String[] args) {
        int a = 2;
        int b = a + 3 * a; // 先算3*a=6，再算2+6=8
        int c = (a + 3) * a; // 先算括号内a+3=5，再算5*2=10
        System.out.println("b=" + b + ", c=" + c); // 输出b=8, c=10
    }
}

二、选择结构语句

（一）if条件语句

1. 三种形式：单条件if、双条件if-else、多条件if-else if-else。
2. 关键规则：判断条件为布尔值，{}可省略但建议保留，避免逻辑错误。
3. 编程案例：

public class IfDemo {
    public static void main(String[] args) {
        int grade = 75;
        if (grade > 80) {
            System.out.println("等级：优");
        } else if (grade > 70) {
            System.out.println("等级：良");
        } else if (grade > 60) {
            System.out.println("等级：中");
        } else {
            System.out.println("等级：差");
        }
    }
}

（二）三元运算符

1. 语法格式：判断条件 ? 表达式1 : 表达式2，条件为true返回表达式1，否则返回表达式2。
2. 关键规则：优先级低于算术和比较运算符，高于赋值运算符，可嵌套使用。
3. 编程案例：

public class TernaryDemo {
    public static void main(String[] args) {
        int x = 5, y = 3;
        int max = x > y ? x : y; // 取x和y的最大值
        int result = x > 10 ? (x * 2) : (y + 5); // 嵌套使用
        System.out.println("max=" + max + ", result=" + result); // 输出max=5, result=8
    }
}

（三）switch条件语句

1. 语法格式：switch(表达式){case 目标值: 执行语句; break; default: 执行语句;}。
2. 关键规则：表达式支持整数、字符等类型，break用于跳出当前case，否则穿透执行；default处理所有case外的情况。
3. 编程案例：

public class SwitchDemo {
    public static void main(String[] args) {
        int week = 5;
        switch (week) {
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
                System.out.println("今天是工作日");
                break;
            case 6:
            case 7:
                System.out.println("今天是休息日");
                break;
            default:
                System.out.println("输入错误");
        }
    }
}

三、循环结构语句

（一）while循环

1. 语法格式：while(循环条件){循环体}，适用于循环次数不确定的场景。
2. 关键规则：先判断条件再执行循环体，需确保循环条件能最终为false，避免无限循环。
3. 编程案例：

public class WhileDemo {
    public static void main(String[] args) {
        int x = 1;
        while (x <= 4) { // 循环4次
            System.out.println("x=" + x);
            x++; // 更新循环变量
        }
    }
}

（二）do-while循环

1. 语法格式：do{循环体}while(循环条件);，循环体至少执行一次。
2. 关键规则：先执行循环体再判断条件，末尾需加英文分号。
3. 编程案例：

public class DoWhileDemo {
    public static void main(String[] args) {
        int x = 1;
        do {
            System.out.println("x=" + x);
            x++;
        } while (x <= 4); // 输出1、2、3、4
    }
}

（三）for循环

1. 语法格式：for(初始化表达式; 循环条件; 操作表达式){循环体}，适用于循环次数明确的场景。
2. 关键规则：执行顺序为初始化→判断条件→循环体→操作表达式，依次循环。
3. 编程案例：

public class ForDemo {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 4; i++) { // 1到4求和
            sum += i;
        }
        System.out.println("sum=" + sum); // 输出10
    }
}

（四）循环嵌套与跳转语句

1. 循环嵌套：循环体内部嵌套另一个循环，常用for嵌套实现复杂逻辑。
2. 跳转语句：break跳出当前循环，continue终止本次循环进入下一次。
3. 编程案例：

public class LoopNestedDemo {
    public static void main(String[] args) {
        // 打印直角三角形（循环嵌套）
        for (int i = 1; i <= 5; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
        // 跳转语句示例
        for (int i = 1; i <= 10; i++) {
            if (i % 2 == 0) {
                continue; // 跳过偶数
            }
            if (i > 7) {
                break; // 大于7则退出循环
            }
            System.out.print(i + " "); // 输出1 3 5 7
        }
    }
}

四、方法

（一）方法的定义与调用

1. 语法格式：修饰符 返回值类型 方法名(参数类型 参数名){执行语句; return 返回值;}。
2. 关键规则：无返回值时返回值类型为void，可省略return；调用时实参与形参类型、个数需一致。
3. 编程案例：

public class MethodDemo {
    // 定义求矩形面积的方法
    public static int getArea(int width, int height) {
        return width * height;
    }
    public static void main(String[] args) {
        int area = getArea(3, 5); // 调用方法
        System.out.println("矩形面积：" + area); // 输出15
    }
}

（二）方法的重载

1. 定义：同一类中，方法名相同但参数个数或参数类型不同（返回值类型不影响重载）。
2. 关键规则：调用时根据实参自动匹配对应的重载方法。
3. 编程案例：

public class MethodOverloadDemo {
    // 两个整数相加
    public static int add(int a, int b) {
        return a + b;
    }
    // 三个整数相加（参数个数不同）
    public static int add(int a, int b, int c) {
        return a + b + c;
    }
    // 两个小数相加（参数类型不同）
    public static double add(double a, double b) {
        return a + b;
    }
    public static void main(String[] args) {
        System.out.println(add(1, 2));       // 输出3
        System.out.println(add(1, 2, 3));    // 输出6
        System.out.println(add(1.2, 2.3));   // 输出3.5
    }
}

五、数组

（一）数组的声明与初始化

1. 声明方式：数据类型[] 数组名，初始化分为动态初始化（指定长度）和静态初始化（直接赋值）。
2. 关键规则：数组索引从0开始，最大索引为数组长度-1，可通过数组名.length获取长度。
3. 编程案例：

public class ArrayInitDemo {
    public static void main(String[] args) {
        // 动态初始化
        int[] arr1 = new int[3];
        arr1[0] = 1;
        arr1[1] = 2;
        // 静态初始化
        int[] arr2 = {3, 4, 5};
        int[] arr3 = new int[]{6, 7, 8};
        System.out.println("arr1[0]=" + arr1[0]); // 输出1
        System.out.println("arr2长度：" + arr2.length); // 输出3
    }
}

（二）数组的常见操作

1. 核心操作：遍历、求最值、插入元素、冒泡排序。
2. 关键规则：数组长度不可变，插入元素需创建新数组；冒泡排序通过相邻元素比较交换实现升序/降序。
3. 编程案例：

public class ArrayOperationDemo {
    public static void main(String[] args) {
        int[] arr = {4, 1, 6, 3, 9, 8};
        // 遍历数组
        System.out.print("遍历结果：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        // 求最大值
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) max = arr[i];
        }
        System.out.println("\n最大值：" + max); // 输出9
        // 冒泡排序（升序）
        for (int i = 1; i < arr.length; i++) {
            for (int j = 0; j < arr.length - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        System.out.print("排序结果：");
        for (int num : arr) {
            System.out.print(num + " "); // 输出1 3 4 6 8 9
        }
    }
}

（三）二维数组

1. 声明方式：支持固定行列、固定行数不固定列数、直接赋值三种方式。
2. 关键规则：通过数组名[行索引][列索引]访问元素，适用于表格类数据存储。
3. 编程案例：

public class TwoDimensionalArrayDemo {
    public static void main(String[] args) {
        // 定义3行2列的二维数组
        int[][] arr = {{11, 12}, {21, 22}, {31, 32}};
        // 遍历二维数组
        int total = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                total += arr[i][j];
                System.out.println("arr[" + i + "][" + j + "]=" + arr[i][j]);
            }
        }
        System.out.println("总和：" + total); // 输出128
    }
}

（四）数组常见异常

1. 核心异常：数组索引越界异常（索引超出0~length-1）、空指针异常（数组变量为null时访问元素）。
2. 编程案例：

public class ArrayExceptionDemo {
    public static void main(String[] args) {
        int[] arr = new int[4];
        // 数组索引越界（注释掉避免报错）
        // System.out.println(arr[4]);
        // 空指针异常（注释掉避免报错）
        arr = null;
        // System.out.println(arr[0]);
    }
}