Java的基本语句结构

判断语句 if - else

if (condition) {
    // 当条件为真时执行的代码块
} else {
    // 当条件为假时执行的代码块
}

• condition 是一个布尔表达式，它决定了执行哪个代码块。如果 condition 为 true，则执行 if 后面的代码块；如果 condition 为 false，则执行 else 后面的代码块（如果有）。

• 大括号 {} 中的代码块定义了在条件成立时执行的语句或操作。每个代码块可以包含一个或多个语句。

示例：

int x = 10;
​
if (x > 5) {
    System.out.println("x 大于 5");
} else {
    System.out.println("x 不大于 5");
}

在这个示例中，如果 x 的值大于 5，则输出 "x 大于 5"；否则，输出 "x 不大于 5"。

可选的 else if 分支

除了 if 和 else 外，还可以使用 else if 来添加多个条件分支。例如：

int x = 10;
​
if (x > 15) {
    System.out.println("x 大于 15");
} else if (x > 10) {
    System.out.println("x 大于 10，但不大于 15");
} else {
    System.out.println("x 不大于 10");
}

在这个例子中，根据 x 的值，程序将输出不同的消息。

注意事项

• if-else 语句中，只有一个代码块会被执行。如果 if 的条件为 true，则执行 if 代码块并跳过 else 代码块；如果 if 的条件为 false，则执行 else 代码块（如果有）。

• else 语句是可选的，一个 if 语句可以单独使用，不必有 else 分支。

三目运算符

三目运算符（Ternary Operator）是一种简洁的条件表达式，也称为条件运算符。在 Java 中，它的基本形式如下：

condition ? expression1 : expression2

它的作用是根据 condition 的结果选择执行 expression1 或者 expression2。

• 如果 condition 为 true，则执行 expression1。

• 如果 condition 为 false，则执行 expression2。

示例

int x = 10;
int y = (x > 5) ? 1 : 0;
System.out.println("y 的值为: " + y);

在这个例子中：

• x > 5 是条件表达式，它的结果为 true，因为 x 的值为 10，大于 5。

• 因此，y 的值被赋为 1，即 expression1 的值。

• 最后输出的结果是 "y 的值为: 1"。

• System.out.println( x > 5 ? "true" : "false"); 后面的表达式可以是字符串 输出结果为 true

特点

• 它是表达式，可以嵌套在其他表达式中使用。

• 它可以用来代替简单的 if-else 结构，使得代码更为紧凑和易读。

• 由于是表达式，因此可以直接用于赋值语句或方法参数中。

注意事项

• 虽然三目运算符可以使代码更简洁，但过度使用可能会影响代码的可读性，尤其是在较复杂的逻辑判断时。

• 在使用三目运算符时，要确保 expression1 和 expression2 的返回类型相同或者兼容，以避免类型转换错误。

public class JavaDemo {
    public static void main(String[] args) {
        int a = 10;
        
        if(a > 10){
            System.out.println("A>10");
        }else if(a == 10){
            System.out.println("A = 10" );
        }else{
            System.out.println("A < 10");
        }
        //System.out.println(a >10 ? "A>10":"A<10");
        //通过嵌套使用三目运算符来代替if-else if-else语句 
        //过度嵌套会影响代码的可读性
        System.out.println(a > 10 ? "A>10" : (a < 10 ? "A<10" : "A = 10"));
    }
}

分支语句swich - case

switch-case 是一种在编程语言中用于根据不同条件执行不同代码块的结构。它适用于当有多个固定值需要比较时，可以提供更清晰和简洁的代码，尤其是当每个条件有不同的处理逻辑时。

基本语法

switch (expression) {
    case value1:
        // 如果 expression 等于 value1，则执行这里的代码
        break;
    case value2:
        // 如果 expression 等于 value2，则执行这里的代码
        break;
    // 可以有更多的 case 分支
    default:
        // 如果 expression 与所有 case 不匹配，则执行这里的代码
}

• switch 关键字：标识开始一个 switch-case 结构，并指定一个表达式（expression），这个表达式的值将会与每个 case 的值进行比较。

• case 分支：每个 case 后面跟着一个固定的值（value），用来和 switch 后面的表达式进行比较。如果表达式的值等于某个 case 的值，则执行该 case 下的代码块。

• break 语句：在每个 case 的代码块末尾通常会有 break 语句，它用来终止 switch 结构，防止执行下一个 case 或 default 分支的代码。如果省略 break，则程序会继续执行下一个 case 或 default 的代码块，直到遇到 break 或者 switch 结束。

• default 分支：如果 switch 表达式的值没有匹配到任何一个 case，则会执行 default 分支中的代码。default 是可选的，可以省略。

注意事项

• 每个 case 中的值必须是常量：在 Java 中，case 后面的值必须是编译时确定的常量表达式，比如整数、字符、枚举常量或者字符串常量。

• switch 表达式的类型：switch 后面的表达式可以是整数类型（byte, short, int, char），枚举类型，或者 String 类型（从 Java 7 开始支持）。

• break 的作用：每个 case 末尾的 break 是为了防止代码继续执行到下一个 case 或 default，除非你确实需要穿透执行多个 case 的代码块，否则不应该省略 break。

示例

int dayOfWeek = 3;
String dayName;
​
switch (dayOfWeek) {
    case 1:
        dayName = "Monday";
        break;
    case 2:
        dayName = "Tuesday";
        break;
    case 3:
        dayName = "Wednesday";
        break;
    case 4:
        dayName = "Thursday";
        break;
    case 5:
        dayName = "Friday";
        break;
    default:
        dayName = "Invalid day";
}
​
System.out.println("Today is " + dayName);

在上面的例子中，switch 结构根据 dayOfWeek 的值来确定 dayName 的赋值，每个 case 对应一个星期几，如果 dayOfWeek 不在 1 到 5 的范围内，则会执行 default 分支，将 dayName 设置为 "Invalid day"。

switch语句也可以通过适当调整排列顺序，不适用break而可以实现相应的功能

    /**
     * 计算一个人的个人所得税是多少
     * 计算方式
     * 如果工资小于5000，不交税
     * 如果工资大于5000 小于等于10000，交超出部分的3%
     * 如果工资大于10000小于等于20000，交超出部分的5%
     * 如果工资大于20000小余等于50000，交超出部分的10%
     * 如果工资大于50000，交超出部分的20%
     * @param money
     * @return
     */
    public Double math1(Double money){
        double ret = 0;
        if(money > 50000){
            //工资大于50000，交超出部分的20%
            ret += (money - 50000) * 0.2;
            money = 50000.0;
        }else if(money > 20000){
            //大于20000小余等于50000，交超出部分的10%
            ret += (money - 20000) * 0.1;
            money = 20000.0;
        }else if(money > 10000){
            //大于10000小于等于20000，交超出部分的5%
            ret += (money - 10000) * 0.05;
            money = 10000.0;
        }else if(money > 5000){
            //大于5000 小于等于10000，交超出部分的3%
            ret += (money - 5000) * 0.03;
        }
        return ret;
    }

    public Double math(Double money){
        int num = (int) (money / 5000);
        double ret = 0;
        //不使用break
        switch (num){
            default:
                ret += (money - 50000) * 0.2;
                money = 50000.0;
            case 9:
            case 8:
            case 7:
            case 6:
            case 5:
            case 4:
            case 3:
                ret += (money - 20000) * 0.1;
                money = 20000.0;
            case 2:
                ret += (money - 10000) * 0.05;
                money = 10000.0;
            case 1:
                ret += (money - 5000) * 0.03;
            case 0:
​
        }
        return ret;
    }

当然也可以有其他的实现方法，这里主要讨论的是不使用break的情况。

循环语句 for

普通的for循环

基本结构如下：

for (initialization; termination; increment/decrement) {
    // 循环体，执行重复操作
}

当使用普通的for循环时，每个部分的作用和可能的省略情况可如下：

Initialization（初始化操作）

初始化操作是在循环开始前执行的一段代码。它通常用于初始化计数器或设置循环开始时的状态。例如：

int i = 0; // 初始化一个计数器
for (; termination; increment/decrement) {
    // 循环体，执行重复操作
}

在这里int i = 0; 就是初始化操作。它可以是任何合法的Java语句，不限于简单的变量初始化，也可以是函数调用或其他表达式。

Termination（循环继续执行的条件）

循环继续执行的条件在每次循环开始前都会被检查。如果条件为false，则循环终止。例如：

javaCopy Codefor (initialization; ; increment/decrement) {
    // 循环体，执行重复操作
}

在这个例子中，分号之间的部分表示termination，它被省略了，因此循环将会无限循环，除非在循环体内部使用break语句或其他方法来终止循环。

Increment/Decrement（增量/减量操作）

增量或减量操作定义了在每次循环迭代结束后如何更新计数器或改变循环条件。例如：

for (initialization; termination; ) {
    // 循环体，执行重复操作
}

在这里，increment/decrement部分被省略了。尽管可以省略增量/减量操作，但通常情况下它们用于控制循环的次数或步长。如

for(int i = 0 ; i < 10 ; i = i + 2){ // 循环体，执行重复操作 }

int i = 0;
for(;i<10;){
    // 循环体，执行重复操作
    i = i + 2;//也可以将increment/decrement部分放在循环体里面
}

注意：

for循环的两个分号是不能省略的，最简的写法为

for( ;  ; ){
    // 循环体，执行重复操作
}
//没有退出条件，就会一直循环

一个完整的普通for循环可以是这样的：

for (int i = 0; i < 5; i++) {
    System.out.println("Iteration " + i);
}

在这个例子中：

• Initialization：int i = 0; 初始化计数器 i。

• Termination：i < 5; 循环条件，当 i 小于 5 时继续执行。

• Increment：i++ 在每次循环结束后将 i 增加 1。

这样的循环会输出：

Iteration 0
Iteration 1
Iteration 2
Iteration 3
Iteration 4

示例

遍历数组

int numbers[] = {1, 2, 3, 4, 5};
​
for (int i = 0; i < numbers.length; i++) {
    System.out.println(numbers[i]);
}

在这个例子中，int i = 0是初始化操作，i < numbers.length是终止条件，i++是增量操作。循环体内通过numbers[i]来访问数组元素

遍历集合

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
​
for (int i = 0; i < names.size(); i++) {
    System.out.println(names.get(i));
}

在这个例子中，int i = 0是初始化操作，i < names.size()是终止条件，i++是增量操作。循环体内通过names.get(i)来访问集合元素。

注意事项

• 适用范围广泛：普通的for循环适用于需要精确控制循环次数或需要访问集合中元素索引的情况。

• 注意数组越界：在访问数组时，要确保索引不会超出数组范围，否则会抛出ArrayIndexOutOfBoundsException异常。

• 效率和可读性：与增强for循环相比，普通的for循环可能更适合需要特定控制流程或需要修改数组元素的情况，但也可能稍显复杂。

适用场景

普通的for循环适用于需要通过索引进行访问或修改数组或集合元素的场景，以及需要精确控制循环次数或执行流程的情况。

增强for循环—foreach

增强for循环（也称为foreach循环）是一种简化遍历集合和数组的语法结构,主要使用于数组、list、set等， 准确说是所有实现了Collection接口的都可以。

for (元素类型 元素变量 : 遍历对象) {
    // 循环体，使用元素变量进行操作
}

• 元素类型：是集合或数组中元素的数据类型，例如 String、Integer 、int等。

• 元素变量：是在每次迭代中，用于代表当前元素的变量名。

• 遍历对象：是要遍历的集合或数组。

使用示例：

1. 数组的遍历：

   int nums[] = {1, 2, 3, 4, 5};
   for (int num : nums) {
       System.out.println(num);
   }

2. List的遍历：

   List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
   for (String name : names) {
       System.out.println(name);
   }

3. Set的遍历：

   Set<Integer> numbers = new HashSet<>(Arrays.asList(1, 2, 3));
   for (int number : numbers) {
       System.out.println(number);
   }

这种循环结构在语法上更加简洁和直观，适合于遍历集合或数组中的所有元素，但不适合需要对索引进行操作或者需要使用迭代器的情况。

循环语句 while 和 do-while

循环语句 while 和 do-while 都是用来重复执行一段代码，直到指定条件不再满足为止。

while 循环

while (条件) {
    // 循环体
}

• 条件 是一个布尔表达式，当条件为 true 时，循环体会重复执行；当条件为 false 时，循环终止，执行循环之后的代码。

• 入口条件循环：在每次迭代开始之前，首先检查条件是否为 true，如果不满足条件，则一次也不执行循环体。

• 可能一次都不执行：如果初始时条件为 false，循环体将不会执行。

示例：

int count = 0;
while (count < 5) {
    System.out.println("Count is: " + count);
    count++;
}

在上面的示例中，循环会重复执行打印 count 的值，直到 count 不再小于 5。

do-while 循环

do {
    // 循环体
} while (条件);

• 循环体 至少会执行一次，然后才会检查条件是否满足。

• 出口条件循环：先执行一次循环体，然后再检查条件是否为 true，如果条件为 true，则继续循环；如果条件为 false，则循环终止。

示例：

int num = 1;
do {
    System.out.println("Number is: " + num);
    num++;
} while (num <= 5);

即使 num 初始值为 1，do-while 循环也会至少执行一次循环体，然后检查条件。

区别

1.执行次数：

while 循环可能一次都不执行循环体，取决于初始条件。

do-while 循环至少会执行一次循环体，即使条件初始时不满足。

2.条件检查时机：

while 循环在每次循环迭代开始前检查条件。

do-while 循环在每次循环迭代结束后检查条件

3.适用场景：

使用 while 当你希望循环体可能一次都不执行时，或者条件很容易在循环体外确定。

使用 do-while 当你确保循环体至少要执行一次时，或者需要在循环体内进行一些初始化工作。

选择使用哪种循环结构取决于具体的需求和设计考虑，两者在功能上都能满足循环的基本需求，但在处理初始条件和循环体执行次数上有所不同。

注意：do-while在处理数组时要先判断数组是否为空，否则容易出现数组下标越界的情况

int arr[] = {1,2,3,4,5,6,7};
int i = 0;
while( i < arr.length){
    System.out.println(arr[i]);
    i++;
}
​
int j = 0;
if(arr.length > 0){
    do{
        //一定会先进来一次 所以要先判断数组是不是为空 否则会出现下标越界
        System.out.print(arr[j]+" ");
        j++;
    }while(j < arr.length);
}