第六章选择语句、循环语句、Debug_debug循环语句-优快云博客

本文详细介绍了程序设计中的流程控制概念，包括选择语句（if、switch）、循环语句（for、while、do...while）及Debug调试技巧。通过丰富的实例演示了如何运用这些语句来实现复杂的逻辑判断和循环操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

第六章选择语句、循环语句、Debug

6.1 流程控制

在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。所以，我们必须清楚每条语句的执行流程。而且，很多时候我们要通过控制语句的执行顺序来实现我们要完成的功能。

6.1.1 分类

顺序结构
分支结构(if, switch)
循环结构(for, while, do…while)

6.1.2 顺序结构

public static void main(String[] args){ 
//顺序执行，根据编写的顺序，从上到下运行 
System.out.println(1); 
System.out.println(2); 
System.out.println(3); 
}

6.1.3 分支结构之if语句

if语句第一种格式： if

if(关系表达式)
｛
 语句体; 
 ｝
//其它语句

执行流程
(1) 首先计算关系表达式的值
(2) 如果关系表达式的值为true就执行语句体
(3) 如果关系表达式的值为false就不执行语句体
(4) 继续执行后面的其他语句

public static void main(String[] args)
{ 
System.out.println("开始"); 
// 定义两个变量 
int a = 10; 
int b = 20; 
//变量使用if判断 
if (a == b)
{ 
System.out.println("a等于b"); 
}
int c = 10; 
if(a == c)
{ 
System.out.println("a等于c"); 
}
System.out.println("结束"); 
｝

if语句第二种格式： if…else

if(关系表达式) 
{ 
语句体1; 
} 
else { 
语句体2; 
}//其它语句

执行流程
(1) 首先计算关系表达式的值
(2) 如果关系表达式的值为true就执行语句体1
(3) 如果关系表达式的值为false就执行语句体2
(4) 继续执行后面的其他语句

public static void main(String[] args) {
System.out.println("开始"); //定义两个变量 
	int a = 10; 
	int b = 20;
 	b = 5; //需求：判断a是否大于b，如果是，在控制台输出：a的值大于b，否则，在控制台输出：a的值不大于b 
 	if(a > b) { 
 System.out.println("a的值大于b");
  } else { 
  System.out.println("a的值不大于b"); 
  }
  System.out.println("结束");
   }

if-else案例
- 需求：任意给出一个整数，请用程序实现判断该整数是奇数还是偶数，并在控制台输出该整数是奇数还是偶数。
- 分析:
  ①为了体现任意给出一个整数，采用键盘录入一个数据
  ②判断整数是偶数还是奇数要分两种情况进行判断，使用if…else结构
  ③判断是否偶数需要使用取余运算符实现该功能 number % 2 == 0
  ④根据判定情况，在控制台输出对应的内容
- 代码实现

public static void main(String[] args) 
{ 
//为了体现任意给出一个整数，采用键盘录入一个数据。(导包，创建对象，接收数据) 
	Scanner sc = new Scanner(System.in); 
	System.out.println("请输入一个整数："); 
	int number = sc.nextInt(); 
	//判断整数是偶数还是奇数要分两种情况进行判断，使用if..else结构 
	//判断是否偶数需要使用取余运算符实现该功能 number % 2 == 0 
	//根据判定情况，在控制台输出对应的内容 
	if(number%2 == 0) 
	{ 
	System.out.println(number + "是偶数");
	 }
	 else { System.out.println(number + "是奇数");
	  } 
	 }

if语句第三种格式： if…else if …else

if (关系表达式1) 
{ 
语句体1; 
} 
else if (关系表达式2) 
{ 
语句体2;
 }... 
 }else if (关系表达式n)
  { 语句体n; 
  } 
  else {
   语句体n+1; 
   }//其它语句

执行流程
(1) 首先计算关系表达式1的值,判断其结果是true还是false
(2) 如果是true就执行语句体1
(3) 如果是false就继续计算关系表达式2,判断其结果是true还是false
(4) 如果是true就执行语句体2
(5) 如果是false就继续计算关系表达式…,判断其结果是true还是false
(6) …
(7) 如果没有任何关系表达式为true，就执行语句体n+1
案例练习:
- 需求:判断两个整数的大小关系
- 分析:两个数字的关系有三种:大于等于小于

public static void main(String[] args) 
{ 
	//比较两个数字的大小 
	int x = 3; 
	int y = 4; 
	if (x > y) 
	{ 
	System.out.println(x + "大于" + y); 
	} else if (x < y) 
	{ 
	System.out.println(x + "小于" + y); 
	} else { 
	System.out.println(x + "等于" + y);
	 } 
	 }

案例练习:
- 需求:键盘录入一个星期数(1,2,…7)，输出对应的星期一，星期二，…星期日
- 规则:
  - 输入 1 输出星期一
    输入 2 输出星期二
    输入 3 输出星期三
    输入 4 输出星期四
    输入 5 输出星期五
    输入 6 输出星期六
    输入 7 输出星期日
  - 输入其它数字输出数字有误


public static void main(String[] args) { 
	System.out.println("开始");
 	// 需求：键盘录入一个星期数(1,2,...7)，输出对应的星期一，星期二，...星期日 
 	System.out.println("请输入一个星期数(1~7)："); 
 	int week = 7; //这里目前没采用键盘录入方式赋值 
 	if(week == 1) { System.out.println("星期一"); } 
 	else if(week == 2) { System.out.println("星期二"); } 
 	else if(week == 3) { System.out.println("星期三"); }
 	 else if(week == 4) { System.out.println("星期四"); } 
 	 else if(week == 5) { System.out.println("星期五"); } 
 	 else if(week == 6) { System.out.println("星期六"); } 
 	 else if(week == 7) { System.out.println("星期六"); }
 	 else { System.out.println(" 数字有误"); }
 	 System.out.println("结束"); 
 	 }

6.1.4 分支结构之switch

switch语句结构

switch(表达式)
{
case 取值 1: 语句块 1;break;
case 取值 n: 语句块 n;break;
default: 语句块 n+1;break;
}

switch 语句有关规则

表达式的返回值必须是下述几种类型之一：int, byte, char, short,String；

case 子句中的取值必须是常量，且所有 case 子句中的取值应是不同的；

default 子句是可选的；

break 语句用来在执行完一个 case 分支后使程序跳出 switch 语句块；如果 case 后面没有写
break 则直接往下面执行！

Case 后面的执行体可写{ }也可以不写{ }

案例：根据用户输入的月份计算季节

public class Demo05 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个月份（1-12）" );
        int i = scanner.nextInt();
        switch (i){
            case 1:
            case 2:
            case 3:
                System.out.println("春季");
                break;
            case 4:
            case 5:
            case 6:
                System.out.println("夏季");
                break;
            case 7:
            case 8:
            case 9:
                System.out.println("秋季");
                break;
            case 10:
            case 11:
            case 12:
                System.out.println("冬季");
                break;

        }
    }
}

6.2 循环语句

6.2.1 循环概述

循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。

6.2.2 循环组成

循环的组成(手写100遍HelloWorld案例):
(1)【初始化表达式1】准备工作:笔墨伺候,最优先唯一执行一次的操作
(2)【循环条件2】条件判断:每次书写前,判断一下,要不要写
(3)【循环体3】循环所要进行的操作:手写一个HelloWorld案例
(4)【步进表达式4】扫尾的工作:每写一次HelloWorld,计数(+1)

6.2.3 循环语句–for

for循环语句格式：

for(
初始化表达式①; 
布尔表达式②; 
步进表达式④)
{ 
循环体③ 
}

格式解释
- 初始化语句：用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样
- 条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去
- 循环体语句：用于表示循环反复执行的内容，简单说就是循环反复执行的事情
- 条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去
执行流程
- 执行顺序：①②③④>②③④>②③④…②不满足为止。
- ①负责完成循环变量初始化
- ②负责判断是否满足循环条件，不满足则跳出循环
- ③具体执行的语句
- ④循环后，循环条件所涉及变量的变化情况

public static void main(String[] args) { 
	//控制台输出10次HelloWorld，不使用循环 
	System.out.println("HelloWorld"); 
	System.out.println("HelloWorld"); 
	System.out.println("HelloWorld"); 
	System.out.println("HelloWorld"); 
	System.out.println("HelloWorld"); 
	System.out.println("HelloWorld"); 
	System.out.println("HelloWorld"); 
	System.out.println("HelloWorld"); 
	System.out.println("HelloWorld"); 
	System.out.println("HelloWorld"); 
	System.out.println("-------------------------"); 
	//用循环改进，循环10次 //定义变量从0开始，循环条件为<10 
	for(int x = 0; x < 10; x++) {
	 System.out.println("HelloWorld"+x); 
	 }
	  }

for循环练习1：在控制台输出1-5和5-1的数据

public static void main(String[] args) 
{ 
	//需求：输出数据1-5 
	for(int i=1; i<=5; i++)
	 { System.out.println(i);
	  }System.out.println("--------");
	   //需求：输出数据5-1 
	   for(int i=5; i>=1; i--) 
	   { System.out.println(i); 
	   }
	    }

for循环练习2：求1-5之间的数据和，并把求和结果在控制台输出

public static void main(String[] args) { 
	//求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0 
	int sum = 0; 
	//从1开始到5结束的数据，使用循环结构完成 
	/* sum += i; //sum = sum + i; 
	第一次：sum + i 是 0 + 1 ; sum结果为 1; 
	第二次：sum + i 是 1 + 2 ; sum结果为 3; 
	第三次：sum + i 是 3 + 3 ; sum结果为 6; 
	第四次：sum + i 是 6 + 4 ; sum结果为 10; 
	第五次：sum + i 是 10 + 5 ; sum结果为 15; */
	for(int i=1; i<=5; i++) { 
	//将反复进行的事情写入循环结构内部 
	// 此处反复进行的事情是将数据 i 加到用于保存最终求和的变量 sum 中 
	sum += i; 
	} 
	}

本题要点
- 今后遇到的需求中，如果带有求和二字，请立即联想到求和变量
- 求和变量的定义位置，必须在循环外部，如果在循环内部则计算出的数据将是错误的
for循环练习3：求1-100之间的偶数和，并把求和结果在控制台输出

public static void main(String[] args) 
{ 	//求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0 			
	int sum = 0; 
	//对1-100的数据求和与1-5的数据求和几乎完全一样，仅仅是结束条件不同 
	for(int i=1; i<=100; i++) { 
	//对1-100的偶数求和，需要对求和操作添加限制条件，判断是否是偶数 
	if(i%2 == 0) { sum += i; } 
	}
	//当循环执行完毕时，将最终数据打印出来 
	System.out.println("1-100之间的偶数和是：" + sum);
	 }

本题要点：
- 今后如果需求带有统计xxx，请先想到计数器变量
- 计数器变量定义的位置，必须在循环外部

6.3 循环扩展知识点

6.3.1 死循环

死循环：也就是循环中的条件永远为true，死循环的是永不结束的循环。例如：while(true){}。
在后期的开发中，会出现使用死循环的场景，例如：我们需要读取用户输入的输入，但是用户输入多少数据我们并不清楚，也只能使用死循环，当用户不想输入数据了，就可以结束循环了，如何去结束一个死循环呢，就需要使用到跳出语句了。
死循环（无限循环）的三种格式
- for(; ; ){}
- while(true){}
- do {} while(true);

6.3.2 嵌套循环

所谓嵌套循环，是指一个循环的循环体是另一个循环。比如for循环里面还有一个for循环，就是嵌套循环。总共的循环次数=外循环次数*内循环次数
嵌套循环格式：

for(初始化表达式①; 循环条件②; 步进表达式⑦) 
{ 
for(初始化表达式③; 循环条件④; 步进表达式⑥) 
{ 执行语句⑤; 
} 
}

嵌套循环执行流程：
- 执行顺序：①②③④⑤⑥>④⑤⑥>⑦②③④⑤⑥>④⑤⑥
- 外循环一次，内循环多次（一圈）。
- 例如：日历中年与月的关系，时钟中分与秒的关系
  - 如 2021年至2023年，一共3年，每年12个月。其中，年份看成外循环，月份看成内循环。
  - 看系统日历时钟
练习：使用嵌套循环，打印2021年至2023年月份，格式：xxxx年x月

public static void main(String[] args) 
{ 
//打印2021年至2023年月份 
//年份是外循环，3年；月份是内循环，12月 
for (int i = 2021; i <= 2023; i++) 
{ 
for (int j = 1; j <= 12; j++) {
 //不换行打印星号 
 System.out.print(i + "年" + j + "月 "); 
 }//内循环打印12个月后，需要一次换行 System.out.println(); 
 } 
 }

6.3.3 流程控制语句(continue, break, return)

continue, break, return三者的作用

public class Test { public static void main(String[] args) 
{ 
	System.out.println("==========开始=========="); 
	printDate(); 
	System.out.println("==========结束=========="); 
	}
	//日期打印 
public static void printDate() { 
	//打印 2021年 - 2023年之间的 每一个月份 
	//外层循环 代表的年份 
	for (int i = 2021; i <= 2023; i++) 
	{ 
	System.out.println("年份i = " + i); 
	//内层循环表示 月份 
	for (int j = 1; j <= 12; j++) 
	{ 
	if(j == 5)
	{ 
	continue; //break; //return; 
	}
	System.out.println("---------- 年份 "+ i +"月份 j = " + j); 
	}
		} 
	} 
}

6.4 Debug调试

6.4.1 什么是Debug模式

是供程序员使用的程序调试工具，它可以用于查看程序的执行流程，也可以用于追踪程序执行过程来调试程序。
使用IDEA的断点调试功能，查看程序的运行过程 Debug调试窗口介绍
在这里插入图片描述

6.4.2 Debug模式操作流程

如何加断点
- 选择要设置断点的代码行，在行号的区域后面单击鼠标左键即可
如何运行加了断点的程序
- 在代码区域右键Debug执行
看哪里
- 看Debugger窗口
看Console窗口
- 点哪里
- 点Step Into (F7)这个箭头，也可以直接按F7
如何删除断点
- 选择要删除的断点，单击鼠标左键即可
- 如果是多个断点，可以每一个再点击一次。也可以一次性全部删除

6.5 编程题

练习一打印输出三角形

练习二答应输出等腰三角形

练习三打印输出菱形

练习四打印输出空心菱形

代码如下：

public class Demo {
    public static void main(String[] args) {
        System.out.println("三角形");
        //三角形
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 2*i+1; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
        System.out.println("等腰三角形");
        //等腰三角形
        for (int i = 0; i < 4; i++) {
            for (int j = i; j <3; j++) {//控制空格
                System.out.print(" ");
            }
            for (int j = 0; j < 2*i+1; j++) {//控制*
                System.out.print("*");
            }
            System.out.println();
        }
        System.out.println("菱形");
        //菱形
        for (int i = 0; i < 7; i++) {
            if (i<=3)
            {
                for (int j = i; j <3; j++) {//控制空格
                    System.out.print(" ");
                }
                for (int j = 0; j < 2*i+1; j++) {//控制*
                    System.out.print("*");
                }
            }
            else {
                for (int j = i-3; j > 0; j--) {
                    System.out.print(" ");
                }
                for (int j = (6-i)*2+1; j >0; j--) {
                    System.out.print("*");
                }
            }
            System.out.println();
        }
        System.out.println("空心菱形");
        //空心菱形
        for (int i = 0; i < 7; i++) {
            if (i<=3)
            {
                for (int j = i; j <3; j++) {//控制空格
                    System.out.print(" ");
                }
                for (int j = 0; j < 2*i+1; j++) {//控制*
                    if (i==0) System.out.print("*");
                    else if(j==0||j==2*i) System.out.print("*");
                    else System.out.print(" ");
                }
            }
            else {
                for (int j = i-3; j > 0; j--) {
                    System.out.print(" ");
                }
                for (int j = (6-i)*2+1; j >0; j--) {
                    if (i==6) System.out.print("*");
                    else if(j==(6-i)*2+1||j==1) System.out.print("*");
                    else System.out.print(" ");
                }
            }
            System.out.println();
        }
    }
}