1.顺序控制
程序从上到下逐行的执行,中间没有任何判断和跳转
执行案例
java
//Java中定义变量时采用合法的向前引用。如:
public class Test{
int num1 = 12;
int num2 = num1 + 2;
}
//错误形式
public class Test{
int num2 = num1 + 12; //报错
int num1 = 12;
}
2.if分支控制
2.1 单分支
基本语法
if(条件表达式){
执行代码块;(可以有多条语句)
}
说明
当条件表达式为true的时候,就会执行{}的代码。如果为false,就不执行。特别说明,如果{}中只有一条语句,则可以不用{}。
流程图
2.2 双分支
基本语法
if(条件表达式){
执行代码块1;(可以有多条语句)
} else {
执行代码块2;(可以有多条语句)
}
说明
当条件表达式成立,即执行代码块1,否则执行代码块2。如果执行代码块只有一条语句,则{}可以省略,否则不能省略。
流程图
2.3 多分支
基本语法
if(条件表达式){
执行代码块1;(可以有多条语句)
} else if {
执行代码块2;(可以有多条语句)
}
.....
else {
执行代码块n;
}
说明
- 多分枝可以没有else,如果所有的条件表达式都不成立,则一个执行入口都没有。
- 如果有else,则所有的条件表达式都不成立,则默认执行else代码块
流程图
2.4 嵌套分支
if(条件表达式){
if(条件表达式){
} else {
}
}
3.switch分支结构
基本语法
1. switch关键字,表示switch分支
2. 表达式对应一个值
3. case常量1:表示当表达式的值等于常量1,就执行语句块1
4. break:表示退出switch
5. 如果和case常量1匹配,就执行语句块1,如果没有匹配,就继续匹配case常量2
6. 如果一个都没有匹配上,就执行default
switch(表达式){
case 常量1:
语句块1;
break;
case 常量2:
语句块2;
break;
....
case 常量n:
语句块n;
break;
default:
default语句块;
break;
}
流程图
使用细节
- 表达式数据类型,应和case后的常量类型保持一致,或者是可以自动转成可以相互比较的类型,比如输入的是字符,而常量是int
- switch表达式中表达式返回值必须是:byte、short、int、char、enum[枚举]、String
java
//错误示例 double类型不能当作表达式的值
double c = 1.1;
switch(c){
case 1.1:
System.out.println("ok");
break;
}
- case子句中的值必须是常量,而不能是变量
- default子句是可选的,当没有匹配的case时,执行default
- break语句用来在执行完一个case分支后使程序跳出switch语句块;如果没有写break,程序会顺序执行到switch结尾,除非遇到break
switch和if的比较
- 如果判断的具体数值不多,而且符合 byte、 short 、int、 char, enum[枚举], String 这 6 种类型。虽然两个语句都可以使用,建议使用switch语句。
- 其他情况:对区间判断,对结果为 boolean 类型判断,使用 if,if 的使用范围更广
4.for循环
4.1 基本语法
说明
- for关键字表示循环控制
- for有四要素: 循环变量初始化、循环条件、循环操作、循环变量迭代
- 循环操作这里可以有多条语句,也就是我们要循环执行的代码
- 如果循环操作语句只有一条语句,可以省略{},建议不要省略
4.2 执行流程分析
执行流程示例
4.3 注意事项与细节
- 循环条件是返回一个布尔值的表达式
- for(;循环判断条件;)中的初始化和变量迭代可以写到其他地方,但是两边的分号不能省略。如果循环变量初始化i放在循环条件的小括号中,i的作用域只能在for循环内,写在for循环外面作用域就会变大。
java
int i = 0;
for (;i < 10;){
System.out.println("hello world" + i);
i++;
}
- 循环初始值可以有多条初始化语句,但是要求类型一样,并且中间用逗号隔开,循环变量迭代也可以有多条变量迭代语句,中间用逗号隔开
- 使用内存分析法分析下面代码
java
1. i=0 j=0 判断 i<3 是true 执行输出 hello world0--0 执行i++ i=1 执行j+=2 j=2
2. i=1 j=2 判断 i<3 是true 执行输出 hello world1--2 执行i++ i=2 执行j+=2 j=4
3. i=2 j=4 判断 i<3 是true 执行输出 hello world2--4 执行i++ i=3 执行j+=2 j=6
3. i=3 j=6 判断 i<3 是false 不执行语句块跳出for循环
4. 所以控制台输出
hello world0--0
hello world1--2
hello world2--4
int count = 3;
for (int i = 0,j = 0;i < count; i++,j+=2){
System.out.println("hello world" + i + "--" + j);
}
5.while循环
基本语法
执行流程
执行案例
- 循环条件是返回一个布尔值的表达式
- while循环是先判断再执行语句
6.do...while循环
基本语法
循环变量初始化;
do{
循环体(语句);
循环变量迭代;
}while(循环条件);
执行流程
执行案例
- 循环条件是返回一个布尔值的表达式
- do..while 循环是先执行,再判断, 因此它至少执行一次
注意事项
- do while 是关键字
- 也有循环四要素, 只是位置不一样
- 先执行,再判断,也就是说,一定会至少执行一次
- 最后while(循环条件) 后面有一个分号;
7.多重循环控制
- 将一个循环放在另一个循环体内,就形成了嵌套循环。其中,for ,while ,do…while 均可以作为外层循环和内层循环。[建议一般使用两层,最多不要超过 3 层, 否则,代码的可读性很差]
- 实质上,嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时,才会完全跳出内层循环,才可结束外层的当次循环,开始下一次的循环。
- 设外层循环次数为m次,内层为 n 次,则内层循环体实际上需要执行m*n次。
java
for(int i = 1;i <= 7;i++){//第一层7次
for(int i = 1;i <= 7;i++){//第二层2次
System.out.println("ok");//总共输出次数14次
}
}
应用案例
java
//执行流程
//1. 执行i=0 判断i<2 true 执行j=0 判断j<3 true 执行输出语句 i=0 j=0 执行 j++ j=1 i=0
//2. i=0 j=1 判断j<3 true 执行输出语句 i=0 j=1 执行j++ j=2 i=0
//3. i=0 j=2 判断j<3 true 执行输出语句 i=0 j=2 执行j++ j=3 i=0
//4. i=0 j=3 执行j<3 false 执行i++ i=1 判断i<2 true i=1
//5. i=1 执行j=0 判断j<3 true 执行输出语句i=1 j=0 执行j++ j=1 i=1
//6. i=1 j=1 判断j<3 true 执行输出语句i=1 j=1 执行j++ j=2 i=1
//7. i=1 j=2 判断j<3 true 执行输出语句i=1 j=2 执行j++ j=3 i=1
//8. i=1 j=2 判断j<3 false 执行i++ i=2 判断i<2 false 跳出循环
for(int i = 0; i < 2; i++) {
for( int j = 0; j < 3; j++) {
System.out.println("i=" + i + j=" + j);
}
}
8.空心金字塔练习题
java
//表示金字塔层数 5层
for (int i = 1; i <= 5; i++) {
//在输出*之前还得输出空格 输出空格数量 = 总层数 - 当前层
for (int k = 0; k < 5 - i; k++) {
System.out.print(" ");
}
//控制每层打印的*数
for (int j = 1; j <= 2 * i - 1; j++) {
//第一个是* 最后一个也是* 最后一层都是*
if (j == 1 || j== 2 * i - 1 || i== 5){
System.out.print("*");
}else {
System.out.print(" ");
}
}
System.out.println("");
}
9.跳转控制语句-break
break语句用于终止某个语句块的执行,一般使用在switch或者循环[for,while,do-while]中
操作案例
java
//1. 循环变量初始化i=0 判断i<10 true 判断i==3 false 执行输出语句 i=0 循环变量迭代i++ i=1
//2. i=1 判断i<10 true 判断i==3 false 执行输出语句 i=1 循环变量迭代i++ i=2
//3. i=2 判断i<10 true 判断i==3 false 执行输出语句 i=2 循环变量迭代i++ i=3
//4. i=3 判断i<10 true 判断i==3 true 执行break跳出while循环 执行输出 "跳出while循环继续执行其他代码"
int i = 0;//循环变量初始化
while (i < 10){//循环条件
if (i == 3) {
break;
}
System.out.println("i=" + i);
i++;//循环变量迭代
}
System.out.println("跳出while循环继续执行其他代码");
break标签
- break语句出现在多层嵌套的语句块中时,可以通过标签指明要终止哪一层语句块
- 标签的使用案例
情景1
break label2的情况和break的效果一样 都是跳出内层for循环 继续执行外层for循环
java
//1. 外层循环变量初始化 i=0 判断 i<4 true 内层环变量初始化 j=0 判断 j<3 true 判断 i==2 false 输出i=0 j=0 内层循环变量迭代 j++ j=1
//2. i=0 j=1 判断j<3 true 判断 i==2 false 输出i=0 j=1 内层循环变量迭代 j++ j=2
//3. i=0 j=2 判断j<3 true 判断 i==2 false 输出i=0 j=2 内层循环变量迭代 j++ j=3
//4. i=0 j=3 判断j<3 false 外层循环变量迭代 i++ i=1
//5. i=1 判断i<4 true 内层环变量初始化 j=0 判断 j<3 true 判断 i==2 false 输出i=1 j=0 内层循环变量迭代 j++ j=1
//6. i=1 j=1 判断j<3 true 判断 i==2 false 输出i=1 j=1 内层循环变量迭代 j++ j=2
//7. i=1 j=2 判断j<3 true 判断 i==2 false 输出i=1 j=2 内层循环变量迭代 j++ j=3
//8. i=1 j=3 判断j<3 false 外层循环变量迭代 i++ i=2
//9. i=2 判断i<4 true 内层环变量初始化 j=0 判断 j<3 true 判断 i==2 true 执行break 跳出label2内层循环 外层循环变量迭代 i++ i=3
//10. i=3 判断i<4 true 内层环变量初始化 j=0 判断 j<3 true 判断 i==2 false 输出i=3 j=0 内层循环变量迭代 j++ j=1
//11. i=3 j=1 判断j<3 true 判断 i==2 false 输出i=3 j=1 内层循环变量迭代 j++ j=2
//12. i=3 j=2 判断j<3 true 判断 i==2 false 输出i=3 j=2 内层循环变量迭代 j++ j=3
//13. i=3 j=3 判断j<3 false 外层循环变量迭代 i++ i=4
//14. i=4 判断i<4 false 跳出外层循环 执行输出语句 "跳出for循环继续执行其他代码"
label1:
for (int i = 0; i < 4; i++) {
label2:
for (int j = 0; j < 3; j++) {
if (i == 2) {
break label2;
}
System.out.println("i=" + i + ",j=" + j);
}
}
System.out.println("跳出for循环继续执行其他代码");
情景2
break label1的情况就是直接跳出外层循环
java
//1. 外层循环变量初始化 i=0 判断 i<4 true 内层环变量初始化 j=0 判断 j<3 true 判断 i==2 false 输出i=0 j=0 内层循环变量迭代 j++ j=1
//2. i=0 j=1 判断j<3 true 判断 i==2 false 输出i=0 j=1 内层循环变量迭代 j++ j=2
//3. i=0 j=2 判断j<3 true 判断 i==2 false 输出i=0 j=2 内层循环变量迭代 j++ j=3
//4. i=0 j=3 判断j<3 false 外层循环变量迭代 i++ i=1
//5. i=1 判断i<4 true 内层环变量初始化 j=0 判断 j<3 true 判断 i==2 false 输出i=1 j=0 内层循环变量迭代 j++ j=1
//6. i=1 j=1 判断j<3 true 判断 i==2 false 输出i=1 j=1 内层循环变量迭代 j++ j=2
//7. i=1 j=2 判断j<3 true 判断 i==2 false 输出i=1 j=2 内层循环变量迭代 j++ j=3
//8. i=1 j=3 判断j<3 false 外层循环变量迭代 i++ i=2
//9. i=2 判断i<4 true 内层环变量初始化 j=0 判断 j<3 true 判断 i==2 true 执行break 跳出label1外层循环 执行输出语句 "跳出for循环继续执行其他代码"
label1:
for (int i = 0; i < 4; i++) {
label2:
for (int j = 0; j < 3; j++) {
if (i == 2) {
break label1;
}
System.out.println("i=" + i + ",j=" + j);
}
}
System.out.println("跳出for循环继续执行其他代码");
10.跳转控制语句continue
- continue语句用于结束本次循环,继续执行下一次循环。
- continue语句出现在多层嵌套的循环语句体中时,可以通过标签指明要跳过的是哪一层循环,这个和前面的标签的使用的规则一样。
应用案例
java
//1. 循环变量初始化i=0 判断i<5 true 循环变量迭代i++ i=1 判断i==3 false 输出i=1
//2. i=1 判断i<5 true 循环变量迭代i++ i=2 判断i==3 false 输出i=2
//3. i=2 判断i<5 true 循环变量迭代i++ i=3 判断i==3 true 跳出本次循环
//4. i=3 判断i<5 true 循环变量迭代i++ i=4 判断i==3 false 输出i=4
//5. i=4 判断i<5 true 循环变量迭代i++ i=5 判断i==3 false 输出i=5
//6. i=5 判断i<5 false 跳出while循环
int i = 0;
while (i < 5){
i++;
if (i == 3){
continue;
}
System.out.println("i=" + i);
}
注意
当在while循环中使用continue的时候,需要将循环条件变量迭代放在continue之前,否则将会造成死循环的情况。 原因是,每次进到下一次循环都是continue条件判断的值,没有迭代,会一直执行continue执行不到循环变量迭代
11.跳转控制语句-return
return使用在方法,表示跳出所在的方法,在方法的时候,会详细的介绍
使用案例
java
for (int i = 0; i < 5; i++) {
if (i == 3){
System.out.println("if 中 i=" + i);
return;//break continue
}
System.out.println("for 中 i=" + i);
}
System.out.println("over");
return
return直接结束该方法,后续代码都不会执行
break
break是跳出循环 继续执行后续代码
continue
continue是跳出本次循环 继续执行下一次循环和后续代码