Java流程控制：选择、循环与递归
本文介绍Java流程控制语句，包括选择结构（if单、双、多分支，switch）、循环结构（while、do - while、for）及递归算法。阐述各结构特点、使用场景，如选择结构处理多分支条件，循环结构用于重复执行代码，递归适合解决可分解为子问题的情况，同时指出递归耗资源的缺点。
Java流程控制语句
本章概述：
- 流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。
- 其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即：顺序结构、分支结构和循环结构，如图下所示：
顺序结构
选择结构：if-else switch
循环结构：while do-while for
跳转：break continue return
多重循环
方法：定义、调用、重载
递归算法
一、选择结构
1.if单分支选择结构
if语句对条件表达式进行一次测试，若测试为真，则执行下面的语句，否则跳过该语句。
//单分支判断，Math.random()产生数据的范围是[0,1)
//得到0~5之间的随机数
double i = 6 * Math.random();
double j = 6 * Math.random();
double k = 6 * Math.random();
int count = (int)(i + j + k);
if(count > 15){
System.out.println("今天天气不错");
}
if(count >= 10 && count <= 15){
System.out.println("今天天气很一般");
}
if(count < 10){
System.out.println("今天天气不怎样");
}
System.out.println("得了" + count + "分");
//条件结果必须是布尔值
//建议都加上花括号。如果不加花括号，则只对第一句话有效！
2.if-else双分支选择结构
当条件表达式为真时，执行语句块1，否则，执行语句块2。也就是else部分。
示例：
double r = 4 * Math.random();
double area = Math.PI * Math.pow(r,2);
double circle = 2 * Math.PI * r;
System.out.println("半径为：" + r);
System.out.println("面积为：" + area);
System.out.println("周长为：" + circle);
if (area >= circle){
System.out.println("面积大于等于周长");
} else {
System.out.println("周长大于面积");
}
3.if-else if-else多分支选择结构
if(布尔表达式1){
语句块1;
} else if(布尔表达式2) {
语句块2;
}…………
else if(布尔表达式n) {
语句块n;
} else {
语句块n+1;
}
逐条if语句进行判断条件匹配，进入语句体，否则对if语句继续匹配。
int age = (int)(Math.random()*100);
if(age < 10){
System.out.println("儿童");
}
else if(age < 20){
System.out.println("少年");
}
else if(age < 30){
System.out.println("青年");
}
else if(age < 50){
System.out.println("中年");
}
else if(age < 70){
System.out.println("老年");
}
else{
System.out.println("耄耋");
}
4.为什么使用嵌套if选择结构
举例：
学校举行运动会，百米赛跑跑入20秒内的学生有资格进决赛，根据性别分别进入男子组和女子组。
分析：
1.要判断是否能够进入决赛
2.在确定进入决赛的情况下，还要判断是进入男子组，还是女子组
这是我们发现一层选择结构无法完成此题要求，这时我们就需要使用嵌套if选择结构：
示例：
if (条件1) {
if (条件2) {
代码块1
} else {
代码块2
}
} else {
代码块3
}
解答：
int time = (int)(Math.random()*40);
if(time < 20){
System.out.println("恭喜进入决赛");
String sex = ((int)(Math.random()*2) == 0 ? "girl" : "boy");
if(sex == "girl"){
System.out.println("欢迎进入女子组");
}
else{
System.out.println("欢迎进入男子组");
}
}
else{
System.out.println("成绩太差，被淘汰");
}
5.switch多分支选择结构
概念： 根据表达式值的不同执行许多不同的操作。
switch(表达式){
case 值1:
语句序列;
[break];
case 值2:
语句序列;
[break];
……………………
[default:
默认语句;]
}
- switch语句会根据表达式的值从相匹配的执行，一直执行到break标签处开始ak语句处或者是switch语句的末尾。与任一case值不匹配，则进入default语句（如果有的话）
- 只能处理等值条件判断的情况，且表达式必须为byte，short，int或char类型，不能是String或double，float。1.7之后可以使用string
- 常量值必须是与表达式类型兼容的特定的一个常量
- 不允许有重复的case值
例：
int random = (int)(Math.random()*26);
char ch = (char)('a' + random);
switch(ch){
case 'a':
System.out.println("元音：" + ch);
break;
case 'e':
System.out.println("元音：" + ch);
break;
case 'i':
System.out.println("元音：" + ch);
break;
case 'o':
System.out.println("元音：" + ch);
break;
case 'u':
System.out.println("元音：" + ch);
break;
case 'y':
System.out.println("半元音：" + ch);
break;
case 'w':
System.out.println("半元音：" + ch);
break;
default:
System.out.println("辅音：" + ch);
break;
注意：
1、每个case模块中添加break，防止多次匹配
2、如果多个case中处理的逻辑代码块的功能一致，可以考虑只在最后添加一次处理
3、default表示默认选项，当所有的case不匹配的是时候，会执行此选项
4、default可以有，也可以没有
6.比较switch和多重if选择结构
相同点：
都是用来处理多分支条件的结构。
不同点：
switch选择结构：只能处理等值条件判断的情况，而且条件必须是整形变量或字符型变量或者字符串（jdk1.7之后）。
多重if选择结构：没有switch选择结构的限制，特别适合某个变量处于某个连续的区间时的情况。
二、循环结构
为什么需要循环？
举例：
张浩Java考试成绩未达到自己的目标。为了表明自己勤奋学习的决心，他决定写一百遍“好好学习，天天向上！”。
解答：
//没有使用循环
System.out.println("第1遍写：好好学习，天天向上！");
System.out.println("第2遍写：好好学习，天天向上！");
System.out.println("第3遍写：好好学习，天天向上！");
System.out.println("第4遍写：好好学习，天天向上！");
……………………
System.out.println("第99遍写：好好学习，天天向上！");
System.out.println("第100遍写：好好学习，天天向上！");
//使用while循环
int i = 1;
while(i <= 100){
System.out.println("第" + i + "遍写：好好学习，天天向上！");
i++;
}
循环的特点：
1.while循环
- 在循环刚开始时，会计算一次“布尔表达式”的值，若条件为真，执行循环体。而对于后来每一次额外的循环，都会在开始前重新计算一次。
- 语句中应有使循环趋向于结束的语句，否则会出现无限循环——“死”循环
示例：
public class WhileTest{
public static void main(String[] args){
//求100内的偶数和
int i = 1;
//求和最终的存储变量
int sum = 0;
while(i <= 100){
if(i % 2 == 0){
sum += i;
}
i++;
}
System.out.println("100以内所有偶数的和是：" + sum);
}
}
循环结构需要四部分组成
初始化：变量的初始化
条件判断：必须要求返回true或者false的值
循环体：具体的要执行的逻辑代码
迭代变量：促使此循环结束
2.do-while循环
do-while:先执行，后判断。
while:先判断，后执行。
public class Test{
public static void main(String[] args){
int i = 1;
int sum = 0;
do{
if(i % 2 == 0){
sum += i;
}
i++;
}while(i <= 100);
System.out.println("100以内的所有偶数的和是：" + sum);
}
}
while和dowhile的区别： dowhile总是保证循环体会被至少执行一次！这是他们的主要差别。
3.for循环
使用for循环的好处：
- 代码简洁
- 变量初始化的时候，for循环的作用域仅仅是当前for循环结构while循环的作用域是从变量的定义开始到整个方法结束
for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。
语法形式：
for(初始表达式;布尔表达式;步进){
循环体;
}
注意事项：
1.for循环在执行条件测试后，先执行程序部分，在执行步进。
2.在for语句的初始化部分声明的变量，其作用域为整个for循环体。
3.“初始化”和“循环条件表达式”部分可以使用逗号来执行多个操作。
4.如果三个部分都为空语句（分号不能省），相当于一个无限循环。
示例：
public class Test{
public static void main(String[] args){
int i = 0;
int sum = 0;
for(i = 1;i <= 100;i++){
if(i % 2 == 0){
sum += i;
}
}
System.out.println("100以内所有的偶数和是：" + sum);
}
}
4.跳转语句—break和continue
1.在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。（break语句还可用于多分支语句switch中）
2.continue语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。
示例：
//生成0~100随机数，直到生成88为止，停止循环！
//break：跳出本层循环，当包含多层循环的时候，break是能跳出内层循环，无法跳出外层循环
public class BreakDemo{
public static void main(String[] args){
int count = 0;
while(true){
int i = (int)(Math.random() * 100);
if(i == 88){
break;
}
count++;
System.out.println(count + "---" + i);
}
}
}
//把100~150之间不能被3整除的数输出
//continue：跳出本次循环
public class ContinueDemo{
public static void main(String[] args){
int i = 0;
for(i = 100;i <= 150;i++){
if(i % 3 == 0){
continue;
}
System.out.println(i);
}
}
}
break：改变程序控制流。
break作用：用于do-while、while、for中时，可跳出循环而执行循环后面的语句。
continue：只能用在循环里。
continue作用：跳出循环体中剩余的语句而执行下一次循环。
对比break和continue：
- 使用场合：break可用于switch结构和循环结构中，而continue只能用于循环结构中。
- 作用（循环结构中）：break语句终止某个循环，程序跳转到循环块外的下一条语句，而continue是跳出本次循环，进入下一次循环。
5.跳转语句—return
return语句从当前方法退出，返回到调用该方法的语句处，并从该语句的下一条语句处继续执行程序。
示例：
public class ReturnDemo{
public static void main(String[] args){
System.out.println(get());
int i = 0;
for(i = 1; i <= 10;i++){
System.out.println(i);
if(i == 5){
return;
}
System.out.println("接着执行");
}
}
public static int get(){
return 100;
}
}
返回语句的两种格式：
- return expression
返回一个值给调用该方法的语句。
返回值的数据类型必须和方法声明中的返回值类型一致或是精度低于声明的数据类型 - return
当方法声明中用void声明返回类型为空时，应使用这种返回类型，它不返回任何值。
跳转语句总结：
break：switch语句、循环语句
continue：循环语句
return：任何语句中，结束当前方法，和循环其实没有什么关系
6.多重循环
三种循环方式： while、do-while、for
多重循环（嵌套循环）：
1.一个循环体内又包含另一个完整的循环结构
2.任何两种循环都可以相互嵌套
3.可以任意层次循环，但是一般不超过3层
多重循环的过程： 外层循环变量变化一次，内层循环变量要变化一遍。
示例：
public class ManyFor{
public static void main(String[] args){
//打印九九乘法表
int i = 0;
int j = 0;
for(i = 1;i < 10;i++){
for(j = 1; j <= i;j++){
System.out.print(j + "*" + i + "=" + i * j + "\t");
}
System.out.println();
}
}
}
在多重循环中使用continue
举例： 3个班级各4名成员参赛，计算每个班级参赛学员平均分，统计成绩大于85分学员数。
解答：
import java.util.Scanner;
public class Practice{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int i = 0;
int j = 0;
int sum = 0;
for(i = 1;i <= 3;i++){
for(j = 1;j <= 4;j++){
System.out.print("请输入" + i + "班第" + j + "位参赛学员的语文成绩：");
int a = sc.nextInt();
System.out.print("请输入" + i + "班第" + j + "位参赛学员的数学成绩：");
int b = sc.nextInt();
System.out.print("请输入" + i + "班第" + j + "位参赛学员的英语成绩：");
int c = sc.nextInt();
System.out.println("通过计算得到该参赛学员的平均分为：" + ((a + b + c) / 3));
if(((a + b + c) / 3) > 85){
sum++;
} else {
continue;
}
}
}
System.out.print("经过统计得成绩大于85分的学员有：" + sum + "个");
}
}
三、递归算法
什么是递归（recursion）：
1.程序调用自生的编程技巧称为递归
2.一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法
递归问题的特点：
1.一个问题可被分解为若干层简单的子问题
2.子问题和其上层问题的解决方案一致
3.外层问题的解决依赖于子问题的解决
递归结构包括两个部分：
1.递归结束条件。解答：什么时候不调用自身方法。如果没有条件，将陷入死循环。
2.递归体。解答：什么时候需要调用自身方法。
递归示例：
import java.util.Scanner;
/*
斐波那契数列，可以选择打印多少个值
*/
public class Fibonacci{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入要打印的斐波那契数列的个数：");
int count = sc.nextInt();
int i = 0;
for(i = 1;i <= count;i++){
System.out.print(getNumber(i) + "\t");
}
}
public static int getNumber(int number){
if(number == 1 || number == 2){
return 1;
}
else{
return getNumber(number - 1) + getNumber(number - 2);
}
}
}
注意：
1.在程序中，能不使用递归就不要使用递归，因为使用递归的时候会加大资源的消耗。如果使用递归的层次比较深，会造成栈溢出。
2.如果不使用递归无法解决问题的话，就必须要使用递归。比如：输出某个磁盘目录下的所有文件的名称。
递归的优点：
简单的程序
递归的缺点：
1.但是递归调用会占用大量的系统堆栈，内存耗用多。
2.在递归调用层次多时速度要比循环慢得多。
递归的使用场合：
1.任何可用递归解决的问题也能使用迭代解决。
2.当递归方法可以更加自然地反映问题，并且易于理解和调试，并且不强调效率问题时，可以采用递归。
3.在要求高性能的情况下尽量避免使用递归，递归既花时间又耗内存。
四、总结
选择结构：
- if语句 单、双、多分支选择结构，等值、不等值判断即可。
- switch语句 只有多分支选择结构 只针对等值判断。
循环结构：
- while循环：先判断再循环，适合循环次数不固定的情况。
- do-while循环：先循环再判断，适合循环次数不固定的情况。
- for循环：适合循环次数固定的情况。
循环跳转语句：
- break：跳出本层循环，跳出外层循环需要结合标签或符号位实现。
- continue：提前结束本次循环。
- return：结束当前方法。
多重循环：
- 任何两种循环都可以相互嵌套。
- 外层循环变量变化一次，内层循环变量变化一遍。
递归：
- 程序调用自身的编程技巧称为递归。
- 递归简单，但是内存耗用多，速度要比循环慢。
- 任何可用递归解决的问题也能使用循环解决，反之不见得
扫一扫
612
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
