8.[Java 基础]流程控制结构

流程控制分类

程序运行的流程控制决定程序是如何运行的, 流程控制主要有以下三种类型:

1. 顺序控制
2. 分支控制
3. 循环控制

顺序结构

• 顺序结构是程序中最常见的结构

• 顺序控制就是程序从上到下逐行执行, 中间没有任何判断和跳转

• 编写程序时需要注意,无论那种流程控制, 变量需要先定义再使用

分支结构

Java提供了两种分支接口 if 语句和 switch 语句,

• if 语句通过判断 boolean 值来决定进入哪个分支

• switch 通过值匹配的方式来决定进入哪个分支

if 条件语句

If 分支控制使用布尔表达式或者布尔类型值, 让程序有选择的执行哪个分支代码, 分支控制有三种:

1. 单分支
2. 双分支
3. 多分支

单分支

• 单分支的基本语法为:

if(条件表达式){

  执行代码块;

}
// 1. 其中条件表达式返回的只能是 boolean 类型的值或者是一个返回 Boolean 类型的值的表达式
// 2. 执行代码块可以是任意条代码语句, 0 条, 1 条, 或多条均可
// 3. 执行代码块会看成一个整体执行

// 当执行代码块只有一条数据时, {} 可以省略, 写为:
if ( 条件语句 ) 执行代码

• 单分支流程图

• 单分支测试代码

public class IfElse01 {
    public static void main(String[] args) {
        // 从控制台获取数值,判断是否大于 100
        Scanner scanner  = new Scanner(System.in);
        int a  = scanner.nextInt();
        if(a>100){
            System.out.println(a+": 大于 100");
        }
        System.out.println("程序继续执行...");
    }
}

双分支

• 基本语法

if ( 条件表达式 ) {
  执行代码块 1
} else {
  执行代码块 2
}
// 1. 当条件表达式返回 true 时执行代码块 1, 否则执行代码块 2
// 2. 如果执行代码看只有一条语句, 则 {} 可以省略
// 3. 其中条件表达式返回的只能是 boolean 类型的值
// 4. 执行代码块可以是任意条代码语句, 0 条, 1 条, 或多条均可

• 双分支流程图

• 双分支代码示例

public class IfElse02 {
    public static void main(String[] args) {
        // 从控制台获取数值,判断是大于 100 还是小于等于 100
        Scanner scanner  = new Scanner(System.in);
        int a  = scanner.nextInt();
        if(a>100){
            System.out.println(a+": 大于 100");
        }else{
            System.out.println(a+": 小于等于 100");
        }
        System.out.println("程序继续执行...");
    }
}

多分支

• 多分支用来判断多种条件的情况

• 使用多分支时, 建议先处理范围交小的条件

• 基本语法

if ( 条件表达式 1) {
  执行代码块 1
} else if( 条件表达式 2 ) {
  执行代码块 2
}...
else{
  执行代码块 n
}
// 1. 当条件表达式1返回 true 时执行代码块 1, 否则判断条件表达式 2 ...
// 2. 直到有条件表达式为 true 时才进入执行对应的代码块
// 3. 如果所有的条件表达式都为 false 则进入 else 语句对应的代码块
// 4. 最后的 else 语句不是必须的

• 多分支流程图

• 测试代码

public class IfElse03 {
    public static void main(String[] args) {
        // 从控制台获取数值,判断该值大于 100 还是小于等于 100
        Scanner scanner = new Scanner(System.in);
        int a = scanner.nextInt();
        if (a > 100) {
            System.out.println(a + ": 大于 100");
        } else if (a == 100) {
            System.out.println(a + ": 等于 100");
        } else {
            System.out.println(a + ": 小于 100");
        }
        System.out.println("程序继续执行...");
    }
}

• 注意情况

public class IfElse05 {
    public static void main(String[] args) {
        int age  = 80;
        if(age > 20){
            System.out.println("青年"); // 打印青年
        }else if(age > 40){
            System.out.println("中年");
        }else if(age > 60){
            System.out.println("老年");
        }
    }
}

根据上面的判断条件会打印少年, 而 根据 age 大小, 应该判断为老年人，这不属于程序问题, 而是逻辑问题

所以我们在使用 if else if 时, 最好将范围小的条件放在最前面, 并且多个条件之间不能有重复的范围

将上面代码修改为:

public class IfElse05 {
    public static void main(String[] args) {
        int age  = 80;
        if(age > 60){
            System.out.println("老年");
        }else if(age <60 && age >= 40){
            System.out.println("中年");
        }else if(age <40 && age >= 20){
            System.out.println("青年");
        }
    }
}

分支嵌套

• 分支嵌套就是在一个分支结构中有完整的嵌套了另一个完整的分支结构

• 里面的分支结构称为内层分支

• 外面的分支结构称为外层分支

• 注意分支的嵌套最好不要超过三层

• 基本语法

// 外层分支
if (条件表达式 1) {
      // 内层分支
      if (条件表达式 2) {
        执行代码块 2
      } else{
        执行代码块 ...
      }
} else{
  执行代码块 ...
}

• 分支嵌套代码示例

public class IfElse04 {
    public static void main(String[] args) {
        // 从控制台获取数值, 如果数据小于 100 判断该数值是奇数还是偶数
        Scanner scanner = new Scanner(System.in);
        int a = scanner.nextInt();
        if( a < 100 ){
            if( a % 2 == 0 ){
                System.out.println(a+" 小于 100 , 是偶数");
            }else{
                System.out.println(a+" 小于 100 , 是奇数");
            }
        }else{
            System.out.println(a+" 大于等于 100");
        }
    }
}

switch

switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支

• switch 语句中的变量类型可以是： byte、short、int 或者 char。从 Java SE 7 开始，switch 支持字符串 String 类型了，同时 case 标签必须为字符串常量
• switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号
• case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量
• 当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句
• 当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句代码块后面代码的执行。
• case 语句不必须要包含 break 语句。
• 如果一个匹配上的 case 语句中没有 break 语句出现，程序会不进行 case 判断，直接执行下一条 case 语句，直到出现 break 语句
• switch 语句可以包含一个 default 分支，default 在没有 case 语句可以匹配switch 中的任何值，一般放到最后，指前面的选项都没有匹配上走的默认项，（可以在任何位置，但建议在最后一个）
• default 分支在最后一位则不需要 break 语句，default 放到中间位置， 如果需要让 switch 终止依然需要 break

switch case 执行时，一定会先进行匹配，匹配成功返回当前 case 的值，再根据是否有 break，判断是否继续输出，或是跳出判断。

• 基本语法

// switch 关键字, 表示 switch 分支
switch(表达式){// 表达式对应这个值, 这个值可以是 byte, short, int chat, String, enum 类型
  case 常量 1: 语句块 1;break; // case 常量1, 表示当表达式的值等于常量 1 执行语句块 1
  case 常量 2: 语句块 2;break; // break 表示退出 switch 
  case 常量 3: 语句块 3;break; // 上面的 case 没有匹配上会继续跟下面的case 做匹配
  default: 语句块 4; break; // 如果前面一个都没有匹配上执行 default 中的代码块
}

• switch 流程图

• 代码示例

public class Switch01 {
    public static void main(String[] args) {
        // 根据输入的数字判断类别
        Scanner scanner  = new Scanner(System.in);
        int a = scanner.nextInt();
        switch(a){
            case 1:
                System.out.println("java"); break;
            case 2:
                System.out.println("c"); break;
            case 3:
                System.out.println("c++"); break;
            default:
                System.out.println("unknow");
        }
    }
}

• 利用穿透进行一些判断

public class Switch02 {
    public static void main(String[] args) {
        // 根据输入的月份判断季度
        Scanner scanner  = new Scanner(System.in);
        int a = scanner.nextInt();
        switch(a){
            case 1:
            case 2:
            case 3:
                System.out.println("第一季度"); break;
            default:
                System.out.println("其他季度");
        }
    }
}

Switch 与 if 比较

switch 语句: 建议用在判断的具体值不多, 并且返回值为 byte, short, int, char, enum, String 这几种时使用

if 语句: 建议用在 范围判断 或结果为 boolean 类型的判断, 并且 if 语句的适用范围更广

循环结构

循环语句可以在满足一定的条件下, 反复执行一段代码, 这段被重复执行的代码被称为循环体, 当到达一定条件时需要把循环条件设置为 false 以结束循环, 当循环条件一直为 true 不变, 则陷入无限循环即死循环.

循环有四个要素

1. 循环变量初始化: 一条或多条语句, 用于完成初始化工作, 初始化操作在循环开始之前进行
2. 循环条件 : 一个返回 Boolean 类型的表达式, 这个表达式的返回值决定是否继续执行循环体
3. 循环执行代码块: 循环的主体, 当循环条件为 true 时会执行这段代码
4. 循环变量迭代: 在循环体之后, 循环条件判断之前执行, 循环变量迭代的目的是让循环在适当的时候结束

while 循环语句

• 基本语法

循环变量初始化;
while (循环条件){
    循环执行代码块;
    循环变量迭代;
}

• while 循环图示

• 代码示例

public class While01 {
    public static void main(String[] args) {
        // 打印 1-100 之间能被 23 整除的数
        int i= 1;
        while(i<=100){
            if(i%23 ==0){
                System.out.println(i);
            }
            i++;
        }
    }
}

do while 循环语句

do while 与 while 的区别就是 while 循环会先判断循环条件在执行循环体,

而 do while 会先执行循环体, 在判断循环条件, 所以无论循环条件是否满足, do while 都会执行一次循环,

然后判断循环条件, 循环条件满足再执行下一次循环

• 基本语法

循环变量初始化;
do{ 
    循环执行代码块;
    循环变量迭代;  
} while (循环条件);

• do while 流程图

  

• 代码示例

public class DoWhile {
    public static void main(String[] args) {
        // 打印 1-100 之间能被 23 整除的数
        int i= 1;
        do{
            if(i%23 ==0){
                System.out.println(i);
            }
            i++;
        }while(i<=100);

    }
}

for 循环语句

for 循环比 while 与 do while 更加简洁, 绝大多数情况下, 可以使用 for 循环代替 while, do while 循环

• 基本语法

for(循环变量初始化; 循环条件; 循环变量迭代){
  循环执行代码块
} // 如果循环代码块只有一条语句, 那么{} 可以省略

• for 循环执行流程图

• 使用for 循环时, 不建议在循环体内修改循环条件变量的值,

• for(;循环判断条件;) 中的初始化和变量迭代可以写到其他地方, 但两边的分号不能省略

• 变量初始化既可以放在圆括号内也可以放在 for 循环之前,

• 循环变量迭代既可以放在圆括号之内也可以放在循环体中,

• for循环的圆括号中, 只有两个分号是必须的, 其他条件都可以省略, 循环条件的默认值为 true, 如果省略了循环条件, 则循环会一直进行, 陷入无限循环.

for(;;){
  Systen.out.println("for 循环 ing")
}

• for 循环代码示例

public class For01 {
    public static void main(String[] args) {

        // 打印 1-100 之间能被 23 整除的数
        for(int i = 1;i<=100;i++){
            if(i%23 ==0){
                System.out.println(i);
            }
        }
    }
}

多重循环

• 多重循环又叫嵌套循环, 即把一个循环体放进另一个循环体内,

• for, while, do…while 都即可以作为外层也可以作为内层的循环

• 当外层循环条件允许则开始执行外层循环体, 内层循环被包含在外层循环体中,

• 当外层循环体执行时, 如果内层循环条件允许, 将一次次的执行内层循环,

• 当内层循环执行结束, 并且外层循环的循环体执行结束, 继续执行外层循环的循环条件判断

• 如果外层循环为 m 次, 内层循环 n 次, 那么嵌套循环一共会执行 m * n 次

• 多重循环流程图

• 多重循环测试代码

public class NestedLoop {
    public static void main(String[] args) {
        for(int i = 0;i<3;i++){
            for(int j = 0;j<2;j++){
                System.out.println("i = "+i+", j = "+j);
            }
        }
    }
}

• 多重循环使用示例

public class NestedLoop02 {
    public static void main(String[] args) {
            // 打印 9*9 乘法表
      for (int i = 1; i <= 9; i++) {
            for(int j = 1;j<=i;j++){
                System.out.print(j+"*"+i+"="+i*j+"  ");
            }
            System.out.println("");
        }
    }
}

控制循环结构

break 结束循环

某些时候, 在出现某种条件时, 需要强制终止循环而不是等到循环条件为 false 时再终止循环, 这时就需要使用到 break

break 语句用于终止某个语句块的执行, 一般使用在 switch 或者循环中

• 基本语法(以 while为例)

循环变量初始化;
while (循环条件){
    循环执行代码块;
      if(条件判断) break;
    循环变量迭代;
}

• break 在循环中的使用示意图

• 测试代码

public class Break01 {
    public static void main(String[] args) {

        // 生成随机数, 看需要多少次才能生成 20
        int i = 0;
        while(true){
            int result = (int)(Math.random()*100);
            if(result == 20){
                break;
            }
            i++;
        }
        System.out.println(i);
    }
}

continue 结束本次循环

• continue 语句用于结束本次循环，继续执行下一次循环

• 基本语法

循环变量初始化;
while (循环条件){
    循环执行代码块;
      if(条件判断) continue;
    循环变量迭代;
}

• continue 流程示意图

• continue 测试代码

public class Continue01 {
    public static void main(String[] args) {
        // 打印 10 以内的所有奇数
        for (int i = 0; i <= 10; i++) {
            if (i % 2 == 0) {
                continue;
            }
            System.out.println(i);
        }
    }
}

循环跳转控制

在使用多层嵌套循环, 使用break 或 continue 时, 可以通过标签指明要终止的是那一层循环

Java 中的标签就是一个后面紧跟着英文冒号的标识符, Java 语言中的标签只放在循环语句之前才有用,

break 后面的标签必须是有效的标签, 即这个标签必须是在 break 所在的循环之前定义, 或所在的循环的外层循环定义

• 基本语法

// break 使用标签终止循环
label1:for(;;){
  label2:while(条件判断){
    label3:do{
      break label2; // 结束 balel2 的循环
    }while();
  }
}

// continue 使用标签终止循环
label1:for(;;){
  label2:while(条件判断){
    label3:do{
      continue label2; // 结束 balel2 的循环
    }while();
  }
}

// break/continue  语句可以指定退出哪层
// label 标签名称可以自己指定

• 测试代码

public class Break02 {
    public static void main(String[] args) {
        label1:for(int i = 0;i<=3;i++){
            label2:for(int j = 3;i>0;j--){
                if(i == j){
                    //break;
                    //break label2;// 结束 label2 标签所在的循环
                    break label1;// 结束 label1 标签所在的循环
                    //break label2; 
                }
                System.out.println("i="+i+", j="+j);
            }
        }
    }
}

使用 return 结束方法

• return 经常使用在方法中, 表示跳出所在的方法, 一旦方法结束, 循环自然也就结束了,
• return写在 main 方法时会直接退出程序

public class Return01 {
    public static void main(String[] args) {
        for(int i = 0;i<10;i++){
            if(i ==3){
                return;
            }
            System.out.println(i);
        }
        System.out.println("完成循环继续执行");
    }
}