当前位置： 首页 > article >正文

【Java从入门到起飞】流程控制语句

article 2025/2/22 23:10:10

文章目录

  • 1. 顺序结构
  • 2. 分支语句
    • 2.1 if-else条件判断结构
      • 2.1.1 基本语法
      • 2.1.3 if...else嵌套
      • 2.1.4 其它说明
    • 2.2 switch-case选择结构
      • 2.2.1 基本语法
      • 2.2.3 利用case的穿透性
      • 2.2.4 if-else语句与switch-case语句比较
  • 3. 循环语句
    • 3.1 for循环
      • 3.1.1 基本语法
    • 3.2 while循环
      • 3.2.1 基本语法
    • 3.3 do-while循环
      • 3.3.1 基本语法
    • 3.4 对比三种循环结构
    • 3.5 "无限"循环
      • 3.5.1 基本语法
    • 3.6 嵌套循环（或多重循环）
      • 3.6.1 使用说明
  • 4. 关键字break和continue的使用
    • 4.1 break和continue的说明
    • 4.2 应用举例
    • 4.3 带标签的使用
  • 5. Scanner：键盘输入功能的实现
      • 5.1 各种类型的数据输入
  • 6. 如何获取一个随机数

1. 顺序结构

顺序结构就是程序从上到下逐行地执行。表达式语句都是顺序执行的。并且上一行对某个变量的修改对下一行会产生影响。

在这里插入图片描述

public class StatementTest{
	public static void main(String[] args){
		int x = 1;
		int y = 2;
		System.out.println("x = " + x);		
        System.out.println("y = " + y);	
        //对x、y的值进行修改
        x++;
        y = 2 * x + y;
        x = x * 10;	
        System.out.println("x = " + x);
        System.out.println("y = " + y);
    }
}

Java中定义变量时采用合法的前向引用。如：

public static void main(String[] args) {
	int num1 = 12;
	int num2 = num1 + 2;
}

错误形式：

public static void main(String[] args) {
	int num2 = num1 + 2;
	int num1 = 12;
}

2. 分支语句

2.1 if-else条件判断结构

2.1.1 基本语法

结构1：单分支条件判断：if

格式：

if(条件表达式)｛
  	语句块;
｝

说明：条件表达式必须是布尔表达式（关系表达式或逻辑表达式）或 布尔变量。

执行流程：

  1. 首先判断条件表达式看其结果是true还是false
  2. 如果是true就执行语句块
  3. 如果是false就不执行语句块

!外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

结构2：双分支条件判断：if…else

格式：

if(条件表达式) { 
  	语句块1;
}else {
  	语句块2;
}

执行流程：

  1. 首先判断条件表达式看其结果是true还是false
  2. 如果是true就执行语句块1
  3. 如果是false就执行语句块2

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

结构3：多分支条件判断：if…else if…else

格式：

if (条件表达式1) {
  	语句块1;
} else if (条件表达式2) {
  	语句块2;
}
...
}else if (条件表达式n) {
 	语句块n;
} else {
  	语句块n+1;
}

说明：一旦条件表达式为true，则进入执行相应的语句块。执行完对应的语句块之后，就跳出当前结构。

执行流程：

  1. 首先判断关系表达式1看其结果是true还是false
  2. 如果是true就执行语句块1，然后结束当前多分支
  3. 如果是false就继续判断关系表达式2看其结果是true还是false
  4. 如果是true就执行语句块2，然后结束当前多分支
  5. 如果是false就继续判断关系表达式…看其结果是true还是false

​ …

n. 如果没有任何关系表达式为true，就执行语句块n+1，然后结束当前多分支。

在这里插入图片描述

当条件表达式之间是“互斥”关系时（即彼此没有交集），条件判断语句及执行语句间顺序无所谓。

当条件表达式之间是“包含”关系时，“小上大下 / 子上父下”，否则范围小的条件表达式将不可能被执行。

2.1.3 if…else嵌套

在 if 的语句块中，或者是在else语句块中，又包含了另外一个条件判断（可以是单分支、双分支、多分支），就构成了嵌套结构。

执行的特点：
（1）如果是嵌套在if语句块中的，只有当外部的if条件满足，才会去判断内部的条件
（2）如果是嵌套在else语句块中的，只有当外部的if条件不满足，进入else后，才会去判断内部的条件

**案例4：**由键盘输入三个整数分别存入变量num1、num2、num3，对它们进行排序(使用 if-else if-else)，并且从小到大输出。

class IfElseTest4 {
	public static void main(String[] args) {
		
			//声明num1,num2,num3三个变量并赋值
			int num1 = 23,num2 = 32,num3 = 12;

			if(num1 >= num2){
				
				if(num3 >= num1)
					System.out.println(num2 + "-" + num1 + "-" + num3);
				else if(num3 <= num2)
					System.out.println(num3 + "-" + num2 + "-" + num1);
				else
					System.out.println(num2 + "-" + num3 + "-" + num1);
			}else{ //num1 < num2
				
				if(num3 >= num2){
					System.out.println(num1 + "-" + num2 + "-" + num3);
				}else if(num3 <= num1){
					System.out.println(num3 + "-" + num1 + "-" + num2);
				}else{
					System.out.println(num1 + "-" + num3 + "-" + num2);
				}
			}
	}
}

2.1.4 其它说明

  • 语句块只有一条执行语句时，一对{}可以省略，但建议保留
  • 当if-else结构是“多选一”时，最后的else是可选的，根据需要可以省略

2.2 switch-case选择结构

2.2.1 基本语法

语法格式：

switch(表达式){
    case 常量值1:
        语句块1;
        //break;
    case 常量值2:
        语句块2;
        //break; 
    // ...
   [default:
        语句块n+1;
        break;
   ]
}

执行流程图：

在这里插入图片描述

执行过程：

第1步：根据switch中表达式的值，依次匹配各个case。如果表达式的值等于某个case中的常量值，则执行对应case中的执行语句。

第2步：执行完此case的执行语句以后，
​ 情况1：如果遇到break,则执行break并跳出当前的switch-case结构
​ 情况2：如果没有遇到break，则会继续执行当前case之后的其它case中的执行语句。—>case穿透
​ …
​ 直到遇到break关键字或执行完所有的case及default的执行语句，跳出当前的switch-case结构

使用注意点：

  • switch(表达式)中表达式的值必须是下述几种类型之一：byte，short，char，int，枚举 (jdk 5.0)，String (jdk 7.0)；

  • case子句中的值必须是常量，不能是变量名或不确定的表达式值或范围；

  • 同一个switch语句，所有case子句中的常量值互不相同；

  • break语句用来在执行完一个case分支后使程序跳出switch语句块；

    如果没有break，程序会顺序执行到switch结尾；

  • default子句是可选的。同时，位置也是灵活的。当没有匹配的case时，执行default语句。

2.2.3 利用case的穿透性

在switch语句中，如果case的后面不写break，将出现穿透现象，也就是一旦匹配成功，不会在判断下一个case的值，直接向后运行，直到遇到break或者整个switch语句结束，执行终止。

案例：编写程序：从键盘上输入2023年的“month”和“day”，要求通过程序输出输入的日期为2023年的第几天。

import java.util.Scanner;

class SwitchCaseTest4 {
	public static void main(String[] args) {
		
		Scanner scan = new Scanner(System.in);

		System.out.println("请输入2023年的month:");
		int month = scan.nextInt();

		System.out.println("请输入2023年的day:");
		int day = scan.nextInt();

		//这里就不针对month和day进行合法性的判断了，以后可以使用正则表达式进行校验。

		int sumDays = 0;//记录总天数
		
		//写法1 ：不推荐（存在冗余的数据）
		/*
		switch(month){
			case 1:
				sumDays = day;
				break;
			case 2:
				sumDays = 31 + day;
				break;
			case 3:
				sumDays = 31 + 28 + day;
				break;
			//....
		
			case 12:
				//sumDays = 31 + 28 + ... + 30 + day;
				break;
		}
		*/

		//写法2：推荐
		switch(month){
			case 12:
				sumDays += 30;//这个30是代表11月份的满月天数
			case 11:
				sumDays += 31;//这个31是代表10月份的满月天数
			case 10:
				sumDays += 30;//这个30是代表9月份的满月天数
			case 9:
				sumDays += 31;//这个31是代表8月份的满月天数
			case 8:
				sumDays += 31;//这个31是代表7月份的满月天数
			case 7:
				sumDays += 30;//这个30是代表6月份的满月天数
			case 6:
				sumDays += 31;//这个31是代表5月份的满月天数
			case 5:
				sumDays += 30;//这个30是代表4月份的满月天数
			case 4:
				sumDays += 31;//这个31是代表3月份的满月天数
			case 3:
				sumDays += 28;//这个28是代表2月份的满月天数
			case 2:
				sumDays += 31;//这个31是代表1月份的满月天数
			case 1:
				sumDays += day;//这个day是代表当月的第几天
		}
		
		System.out.println(month + "月" + day + "日是2023年的第" + sumDays + "天");
        //关闭资源
		scan.close();
	}
}

2.2.4 if-else语句与switch-case语句比较

  • 结论：凡是使用switch-case的结构都可以转换为if-else结构。反之，不成立。

  • 开发经验：如果既可以使用switch-case，又可以使用if-else，建议使用switch-case。因为效率稍高。

  • 细节对比：

    • if-else语句优势
      • if语句的条件是一个布尔类型值，if条件表达式为true则进入分支，可以用于范围的判断，也可以用于等值的判断，使用范围更广。
      • switch语句的条件是一个常量值（byte,short,int,char,枚举,String），只能判断某个变量或表达式的结果是否等于某个常量值，使用场景较狭窄。
    • switch语句优势
      • 当条件是判断某个变量或表达式是否等于某个固定的常量值时，使用if和switch都可以，习惯上使用switch更多。因为效率稍高。当条件是区间范围的判断时，只能使用if语句。
      • 使用switch可以利用穿透性，同时执行多个分支，而if…else没有穿透性。

3. 循环语句

  • 理解：循环语句具有在某些条件满足的情况下，反复执行特定代码的功能。

  • 循环结构分类：

    • for 循环
    • while 循环
    • do-while 循环

  • 循环结构四要素：

    • 初始化部分
    • 循环条件部分
    • 循环体部分
    • 迭代部分

3.1 for循环

3.1.1 基本语法

语法格式：

for (①初始化部分; ②循环条件部分; ④迭代部分)｛
         	③循环体部分;
｝

**执行过程：**①-②-③-④-②-③-④-②-③-④-…-②

图示：
在这里插入图片描述

说明：

  • for(;;)中的两个；不能多也不能少
  • ①初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔
  • ②循环条件部分为boolean类型表达式，当值为false时，退出循环
  • ④可以有多个变量更新，用逗号分隔

说明：

1、我们可以在循环中使用break。一旦执行break，就跳出当前循环结构。

2、小结：如何结束一个循环结构？

​ 结束情况1：循环结构中的循环条件部分返回false

​ 结束情况2：循环结构中执行了break。

3、如果一个循环结构不能结束，那就是一个死循环！我们开发中要避免出现死循环。

3.2 while循环

3.2.1 基本语法

语法格式：

①初始化部分
while(②循环条件部分)｛
    ③循环体部分;
    ④迭代部分;
}

**执行过程：**①-②-③-④-②-③-④-②-③-④-…-②

图示：

说明：

  • while(循环条件)中循环条件必须是boolean类型。
  • 注意不要忘记声明④迭代部分。否则，循环将不能结束，变成死循环。
  • for循环和while循环可以相互转换。二者没有性能上的差别。实际开发中，根据具体结构的情况，选择哪个格式更合适、美观。
  • for循环与while循环的区别：初始化条件部分的作用域不同。

3.3 do-while循环

3.3.1 基本语法

语法格式：

①初始化部分;
do{
	③循环体部分
	④迭代部分
}while(②循环条件部分);

**执行过程：**①-③-④-②-③-④-②-③-④-…-②

图示：
在这里插入图片描述

说明：

  • 结尾while(循环条件)中循环条件必须是boolean类型
  • do{}while();最后有一个分号
  • do-while结构的循环体语句是至少会执行一次，这个和for和while是不一样的
  • 循环的三个结构for、while、do-while三者是可以相互转换的。

3.4 对比三种循环结构

  • 三种循环结构都具有四个要素：
    • 循环变量的初始化条件
    • 循环条件
    • 循环体语句块
    • 循环变量的修改的迭代表达式
  • 从循环次数角度分析
    • do-while循环至少执行一次循环体语句。
    • for和while循环先判断循环条件语句是否成立，然后决定是否执行循环体。
  • 如何选择
    • 遍历有明显的循环次数（范围）的需求，选择for循环
    • 遍历没有明显的循环次数（范围）的需求，选择while循环
    • 如果循环体语句块至少执行一次，可以考虑使用do-while循环
    • 本质上：三种循环之间完全可以互相转换，都能实现循环的功能

3.5 "无限"循环

在这里插入图片描述

3.5.1 基本语法

语法格式：

  • 最简单"无限"循环格式：while(true) , for(;;)

适用场景：

  • 开发中，有时并不确定需要循环多少次，需要根据循环体内部某些条件，来控制循环的结束（使用break）。
  • 如果此循环结构不能终止，则构成了死循环！开发中要避免出现死循环。

3.6 嵌套循环（或多重循环）

3.6.1 使用说明

  • 所谓嵌套循环，是指一个循环结构A的循环体是另一个循环结构B。比如，for循环里面还有一个for循环，就是嵌套循环。其中，for ,while ,do-while均可以作为外层循环或内层循环。
    • 外层循环：循环结构A
    • 内层循环：循环结构B
  • 实质上，嵌套循环就是把内层循环当成外层循环的循环体。只有当内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的外层循环。
  • 设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次。
  • **技巧：**从二维图形的角度看，外层循环控制行数，内层循环控制列数。
  • **开发经验：**实际开发中，我们最多见到的嵌套循环是两层。一般不会出现超过三层的嵌套循环。如果将要出现，一定要停下来重新梳理业务逻辑，重新思考算法的实现，控制在三层以内。否则，可读性会很差。

例如：两个for嵌套循环格式

for(初始化语句①; 循环条件语句②; 迭代语句⑦) {
    for(初始化语句③; 循环条件语句④; 迭代语句⑥) {
      	循环体语句⑤;
    }
}

//执行过程：① - ② - ③ - ④ - ⑤ - ⑥ - ④ - ⑤ - ⑥ - ... - ④ - ⑦ - ② - ③ - ④ - ⑤ - ⑥ - ④..

**执行特点：**外层循环执行一次，内层循环执行一轮。

4. 关键字break和continue的使用

4.1 break和continue的说明

			适用范围			在循环结构中使用的作用						相同点

break		switch-case
			循环结构			一旦执行，就结束(或跳出)当前循环结构		    此关键字的后面，不能声明语句

continue	循环结构			一旦执行，就结束(或跳出)当次循环结构		    此关键字的后面，不能声明语句

此外，很多语言都有goto语句，goto语句可以随意将控制转移到程序中的任意一条语句上，然后执行它，但使程序容易出错。Java中的break和continue是不同于goto的。

4.2 应用举例

class BreakContinueTest1 {
	public static void main(String[] args) {
	
		for(int i = 1;i <= 10;i++){
			
			if(i % 4 == 0){
				//break;//123
				continue;//123567910
				//如下的语句不可能被执行，编译不通过
				//System.out.println("今晚迪丽热巴要约我吃饭");
			}

			System.out.print(i);
		}

		System.out.println("####");

		//嵌套循环中的使用
		for(int i = 1;i <= 4;i++){
		
			for(int j = 1;j <= 10;j++){
				if(j % 4 == 0){
					//break; //结束的是包裹break关键字的最近的一层循环！
					continue;//结束的是包裹break关键字的最近的一层循环的当次！
				}
				System.out.print(j);
			}
			System.out.println();
		}

	}
}

4.3 带标签的使用

break语句用于终止某个语句块的执行
{    ……	 
	break;
	 ……
}

break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块 
	label1: {   ……        
	label2:	     {   ……
	label3:			 {   ……
				           break label2;
				           ……
					 }
			     }
			}

  • continue语句出现在多层嵌套的循环语句体中时，也可以通过标签指明要跳过的是哪一层循环。

  • 标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。

  • 举例：

class BreakContinueTest2 {
	public static void main(String[] args) {
		l:for(int i = 1;i <= 4;i++){
		
			for(int j = 1;j <= 10;j++){
				if(j % 4 == 0){
					//break l;
					continue l;
				}
				System.out.print(j);
			}
			System.out.println();
		}
	}
}

5. Scanner：键盘输入功能的实现

  • 如何从键盘获取不同类型（基本数据类型、String类型）的变量：使用Scanner类。

  • 键盘输入代码的四个步骤：

    1. 导包：import java.util.Scanner;
    2. 创建Scanner类型的对象：Scanner scan = new Scanner(System.in);
    3. 调用Scanner类的相关方法（next() / nextXxx()），来获取指定类型的变量
    4. 释放资源：scan.close();

  • 注意：需要根据相应的方法，来输入指定类型的值。如果输入的数据类型与要求的类型不匹配时，会报异常 导致程序终止。

5.1 各种类型的数据输入

**案例：**小明注册某交友网站，要求录入个人相关信息。如下：

请输入你的网名、你的年龄、你的体重、你是否单身、你的性别等情况。

//① 导包
import java.util.Scanner;

public class ScannerTest1 {

    public static void main(String[] args) {
        //② 创建Scanner的对象
        //Scanner是一个引用数据类型，它的全名称是java.util.Scanner
        //scanner就是一个引用数据类型的变量了，赋给它的值是一个对象（对象的概念我们后面学习，暂时先这么叫）
        //new Scanner(System.in)是一个new表达式，该表达式的结果是一个对象
        //引用数据类型  变量 = 对象;
        //这个等式的意思可以理解为用一个引用数据类型的变量代表一个对象，所以这个变量的名称又称为对象名
        //我们也把scanner变量叫做scanner对象
        Scanner scanner = new Scanner(System.in);//System.in默认代表键盘输入
        
        //③根据提示，调用Scanner的方法，获取不同类型的变量
        System.out.println("欢迎光临你好我好交友网站！");
        System.out.print("请输入你的网名：");
        String name = scanner.next();

        System.out.print("请输入你的年龄：");
        int age = scanner.nextInt();

        System.out.print("请输入你的体重：");
        double weight = scanner.nextDouble();

        System.out.print("你是否单身（true/false)：");
        boolean isSingle = scanner.nextBoolean();

        System.out.print("请输入你的性别：");
        char gender = scanner.next().charAt(0);//先按照字符串接收，然后再取字符串的第一个字符（下标为0）

        System.out.println("你的基本情况如下：");
        System.out.println("网名：" + name + "\n年龄：" + age + "\n体重：" + weight + 
                           "\n单身：" + isSingle + "\n性别：" + gender);
        
        //④ 关闭资源
        scanner.close();
    }
}

6. 如何获取一个随机数

如何产生一个指定范围的随机整数？

1、Math类的random()的调用，会返回一个[0,1)范围的一个double型值

2、Math.random() * 100 —> [0,100)
(int)(Math.random() * 100) —> [0,99]
(int)(Math.random() * 100) + 5 ----> [5,104]

3、如何获取[a,b]范围内的随机整数呢？(int)(Math.random() * (b - a + 1)) + a

4、举例

		System.out.println(value);

		//[1,6]
		int number = (int)(Math.random() * 6) + 1; //
		System.out.println(number);
	}
}
class MathRandomTest {
	public static void main(String[] args) {
		double value = Math.random();

		System.out.println(value);

		//[1,6]
		int number = (int)(Math.random() * 6) + 1; //
		System.out.println(number);
	}
}


		System.out.println(value);

		//[1,6]
		int number = (int)(Math.random() * 6) + 1; //
		System.out.println(number);
	}
}

http://www.kler.cn/a/555133.html

相关文章：

  • 《跟李沐学 AI》AlexNet论文逐段精读学习心得 | PyTorch 深度学习实战
  • 【干货分享】Autosar CanIf 模块的应用干货笔记1
  • Python使用过程中哪些字符是非法的？
  • 【Linux】多线程 -＞ 线程同步与基于BlockingQueue的生产者消费者模型
  • 分割回文串力扣--131
  • virtualbox怎么把主机剪切板里的内容复制进来
  • 人工智能之视频分割模型sam2源码解读
  • DeepSeek全栈技术体系解密：从算法源码到企业级智能体开发实战
  • [Windows] WPS 2024冬季更新版（版本号19770）
  • MYSQL总结(3)
  • 测试WSS服务器
  • 在UBUNTU下搭建Deepseek
  • 爬虫获取数据后的清洗与校验：完整指南
  • 【Elasticsearch】搜索时排序规则
  • Android Http-server 本地 web 服务
  • PyTorch Tensor 形状变化操作详解
  • 使用Spring Boot构建电商订单系统API的实践
  • 磐维数据库双中心容灾流复制集群搭建
  • dockerfile 使用环境变量
  • 新品 | 杰和科技最新发布搭载英特尔N95处理器的一体机主板CB4-208-U1