Java 流程控制

tk一周目

已于 2023-07-30 15:42:48 修改

阅读量25

点赞数

分类专栏： Java学习文章标签： java 开发语言

于 2023-07-26 15:24:40 首次发布

本文链接：https://blog.csdn.net/weixin_48656469/article/details/131940257

版权

Java学习专栏收录该内容

27 篇文章 1 订阅

订阅专栏

三种基本逻辑结构

在Java中，控制流程是通过不同类型的控制语句来实现的，这些语句用于决定程序的执行路径。主要的控制流程语句包括条件控制语句（if-else，switch），循环语句（for，while，do-while），以及跳转语句（break，continue，return）。

顺序结构

顺序结构是计算机程序中最简单、最基本的控制流程。它是指程序按照代码的顺序依次执行，每个语句一次执行一个，没有跳转或分支。

在顺序结构中，每个语句按照代码的书写顺序顺序执行，没有条件判断、循环或跳转语句来改变执行的流程。一旦一个语句执行完毕，就会顺序执行下一个语句，直到程序结束。

下面是一个使用顺序结构编写的简单Java程序示例：

public class SequentialExample {
    public static void main(String[] args) {
        // 顺序结构示例
        System.out.println("Start of the program.");
        
        int num1 = 10;
        int num2 = 5;
        
        int sum = num1 + num2;
        System.out.println("The sum of " + num1 + " and " + num2 + " is: " + sum);
        
        int product = num1 * num2;
        System.out.println("The product of " + num1 + " and " + num2 + " is: " + product);
        
        System.out.println("End of the program.");
    }
}

在这个示例中，程序按照从上到下的顺序执行，先输出 “Start of the program.”，然后计算num1和num2的和并输出结果，接着计算它们的乘积并输出结果，最后输出 “End of the program.”。这是一个典型的顺序结构，每个语句按照代码的书写顺序依次执行，没有分支或循环来改变执行顺序。

顺序结构是程序设计的基础，大多数程序都由顺序结构组成，通过组合顺序结构、条件控制和循环结构，可以实现复杂的程序逻辑和算法。

选择结构

if-else

在Java中，if-else语句是一种条件控制结构，用于根据给定条件来执行不同的代码块。if-else语句的基本语法如下：

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

condition是一个布尔表达式，它的值可以是true或false，用于判断条件是否成立。
如果condition为true，则执行if代码块中的语句。
如果condition为false，则执行else代码块中的语句（如果有的话）。

以下是一个简单的if-else语句的示例：

javaCopy code
public class IfElseExample {
    public static void main(String[] args) {
        int age = 25;

        if (age >= 18) {
            System.out.println("You are an adult.");
        } else {
            System.out.println("You are a minor.");
        }
    }
}

在这个示例中，根据age的值，如果age大于等于18，输出 “You are an adult.”；否则，输出 “You are a minor.”。这是一个简单的条件判断，根据条件的结果来执行不同的代码块。

除了单独的if-else语句，还可以使用多个if-else if-else语句来处理更复杂的条件判断。例如：

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

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

在这个示例中，根据score的分数范围，输出对应的等级。根据不同的条件，程序会执行不同的代码块。

if-else语句是Java中常用的条件控制结构，它允许根据不同的条件来进行不同的操作，增强了程序的灵活性。

switch-case

用于多分支条件判断的控制语句。它可以根据一个表达式的值，从一组候选项中选择执行的代码块。switch语句适用于当有多个条件需要判断时，避免使用连续的if-else语句，提高代码的可读性。

switch (expression){
    case value1:
        statements...
        break;
    case value2:
        statements...
        break;
    //更多的case语句
    default：
        //默认情况下的代码块
        statements...
        break;
}

expression 是一个表达式，通常是一个整数、字符、枚举或字符串。switch语句将根据该表达式的值来选择执行哪个代码块。
case value1、case value2 等是用于匹配expression值的选项。当expression的值与某个case后的value匹配时，就会执行对应的代码块。
每个case后面的代码块可以包含多条语句。
break语句用于跳出switch语句，即在执行完匹配的代码块后立即退出整个switch语句。如果省略break，则会继续执行下一个case的代码块，直到遇到break或switch结束。
default是可选的，用于当expression的值没有与任何case匹配时执行的代码块。它类似于if-else语句中的else部分。

以下是一个示例，展示了switch语句的用法：

int dayOfWeek = 3;
String dayName;

switch (dayOfWeek) {
    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("Today is " + dayName);

在这个示例中，根据dayOfWeek的值，switch语句会选择执行对应的代码块，并输出相应的星期几名称。如果dayOfWeek的值不在1到7之间，default代码块将会被执行，输出"Invalid day"。

循环结构

while

在Java中，while是一种循环控制结构，它允许在满足给定条件的情况下，重复执行一组代码块。while循环会在循环体内部的条件为真（true）时持续执行，直到条件为假（false）时才会停止循环。

while循环的基本语法如下：

while (condition) {
    // 循环体（当条件为真时执行的代码块）
}

condition是一个布尔表达式，它的值可以是true或false，用于判断是否继续执行循环体。
如果condition为true，则会执行循环体中的代码块，并再次检查condition是否为true，然后继续执行循环体。
如果condition为false，循环终止，程序会跳出while循环，继续执行while循环后的其他代码。

以下是一个简单的while循环的示例：

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

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

在这个示例中，初始化count为0，然后进入while循环。在每次循环迭代中，会输出当前的count值，然后count自增1。while循环条件是count < 5，当count的值小于5时，继续执行循环体；当count的值达到5或更大时，循环终止，程序跳出循环。

while循环允许根据条件动态控制循环的执行，它常用于处理未知数量的迭代次数。当你希望在满足某个条件的情况下重复执行一组代码时，while循环是一个非常有用的控制结构。请注意，要确保循环条件能在某个时刻变为false，否则可能导致无限循环。在编写while循环时，需要仔细选择循环条件，以避免造成死循环。

do-while

在Java中，do-while是一种循环控制结构，类似于while循环，但与while循环的区别在于，do-while循环会先执行循环体中的代码块，然后再检查循环条件是否满足。这意味着无论循环条件是否为真，do-while循环至少会执行一次循环体。

do-while循环的基本语法如下：

do {
    // 循环体（当条件为真时执行的代码块）
} while (condition);

condition是一个布尔表达式，它的值可以是true或false，用于判断是否继续执行循环体。
首先，会执行一次循环体中的代码块，然后检查condition是否为true。
如果condition为true，则继续执行循环体，并再次检查condition是否为true，然后继续执行循环体。
如果condition为false，循环终止，程序会跳出do-while循环，继续执行do-while循环后的其他代码。

以下是一个简单的do-while循环的示例：

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

        do {
            System.out.println("Count: " + count);
            count++;
        } while (count < 5);
    }
}

在这个示例中，初始化count为0，然后进入do-while循环。在每次循环迭代中，会输出当前的count值，然后count自增1。do-while循环条件是count < 5，当count的值小于5时，继续执行循环体；当count的值达到5或更大时，循环终止，程序跳出循环。

与while循环相比，do-while循环更适合在循环体内的代码至少要执行一次的情况。当你希望在循环之前先执行一组代码，然后根据条件重复执行循环体时，do-while循环是一个非常有用的控制结构。同样需要注意循环条件的设置，以避免死循环。

for

在Java中，for循环是一种常用的循环控制结构，它允许根据循环计数器的变化，重复执行一组代码块。for循环通常用于已知循环次数的情况。

for循环的基本语法如下：

for (initialization; condition; update) {
    // 循环体（当条件为真时执行的代码块）
}

initialization：循环开始前的初始化操作，在第一次迭代之前执行，通常用于初始化循环计数器。
condition：循环的条件表达式，当条件为真（true）时，执行循环体。在每次循环迭代之前，会检查该条件是否为真。
update：循环迭代后的更新操作，在每次循环体执行完毕后执行，通常用于更新循环计数器的值。

以下是一个简单的for循环的示例：

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

在这个示例中，for循环的初始化部分是int i = 0，将循环计数器i初始化为0。for循环的条件部分是i < 5，当i的值小于5时，执行循环体。在每次循环迭代之后，循环计数器i会自增1，即i++。

因为i的初始值是0，所以for循环将执行5次，每次迭代输出 "Iteration: " 加上当前的循环计数器值。

for循环是Java中最常用的循环控制结构之一，它非常适合用于处理已知循环次数的情况。在编写for循环时，需要特别注意循环计数器的初始化、条件判断和更新，以确保循环能够正确执行。

转向控制

break

在Java中，break是一种跳转语句，用于提前结束当前循环或switch语句的执行，并跳出该结构，继续执行循环或switch语句之后的代码。

break语句的用法如下：

在循环中使用break：

for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break; // 跳出循环，终止循环的执行
    }
    System.out.println(i);
}

在这个例子中，当i的值等于5时，break语句被执行，跳出for循环，循环终止。因此，只会输出0到4的数字。

在switch语句中使用break：

int dayOfWeek = 3;
switch (dayOfWeek) {
    case 1:
        System.out.println("Sunday");
        break;
    case 2:
        System.out.println("Monday");
        break;
    case 3:
        System.out.println("Tuesday");
        break;
    default:
        System.out.println("Invalid day");
        break;
}

在switch语句中，每个case后面都有一个break语句，用于跳出switch语句。如果省略break，将会继续执行下一个case的代码块，直到遇到break或switch结束。

break语句是一种控制流程的重要工具，它可以用于在满足某个条件时提前结束循环，或者从多个条件中选择并执行一个分支。需要注意，break只会影响最内层的循环或switch语句，如果在嵌套结构中使用，只会跳出最近的一层循环或switch。

continue

在Java中，continue是一种跳转语句，用于结束当前循环迭代，并继续执行下一次循环迭代。当continue语句被执行时，它会立即跳过当前循环体中continue之后的代码，然后执行循环的更新部分，继续进行下一次循环迭代。

continue语句的用法如下：

for (int i = 0; i < 5; i++) {
    if (i == 2) {
        continue; // 结束当前循环迭代，继续下一次迭代
    }
    System.out.println(i);
}

在这个例子中，当i的值等于2时，continue语句被执行，跳过输出语句System.out.println(i);，然后执行循环的更新部分i++，继续下一次循环迭代。因此，输出结果将是0、1、3、4，而2被跳过了。

continue语句通常用于处理某些特定情况下，我们希望跳过当前迭代并继续下一次迭代。在循环内部使用continue可以帮助我们避免不必要的操作或处理特殊情况。需要注意，continue只会影响当前循环的迭代，如果在嵌套循环中使用，只会影响最内层的循环迭代。

return

在Java中，return是一种关键字，用于从方法中返回结果并终止方法的执行。当方法执行到return语句时，它会立即停止当前方法的执行，并将控制权返回给调用该方法的地方。同时，return语句可以返回一个值（或对象引用），作为方法的返回值。

return语句的用法如下：

方法返回类型为void时，用于终止方法的执行，不返回任何值：

public void printMessage() {
    System.out.println("Hello, World!");
    // 执行到return语句，方法结束，不返回值
    return;
}

方法返回类型为其他数据类型时，用于返回相应的值，并终止方法的执行：

public int add(int a, int b) {
    int sum = a + b;
    // 执行到return语句，将sum作为方法的返回值返回，同时方法结束
    return sum;
}

方法返回类型为对象时，用于返回对象的引用，并终止方法的执行：

public Person createPerson(String name, int age) {
    Person person = new Person(name, age);
    // 执行到return语句，将person对象的引用作为方法的返回值返回，同时方法结束
    return person;
}

在方法内部，return语句可以出现在多个地方，但只有一个return语句会被执行。一旦执行到return语句，方法的执行会立即终止，后续的代码将不再执行。

需要注意的是，return语句通常用于将计算结果或处理结果返回给方法的调用者。在有返回值的方法中，必须确保每个可能的执行路径（包括条件分支、循环等）都有相应的return语句，以保证方法在任何情况下都能返回正确的值。在void类型的方法中，return语句用于显式终止方法的执行，但不返回值。