Skip to content

1.顺序控制

程序从上到下逐行的执行,中间没有任何判断和跳转

执行案例

java
//Java中定义变量时采用合法的向前引用。如:
public class Test{
    int num1 = 12;
    int num2 = num1 + 2;
}

//错误形式
public class Test{
    int num2 = num1 + 12; //报错
    int num1 = 12;
}

img_31.png

2.if分支控制

2.1 单分支

基本语法

if(条件表达式){   
    执行代码块;(可以有多条语句)
}

说明
当条件表达式为true的时候,就会执行{}的代码。如果为false,就不执行。特别说明,如果{}中只有一条语句,则可以不用{}。

流程图
img_32.png

2.2 双分支

基本语法

if(条件表达式){   
    执行代码块1;(可以有多条语句)
} else {   
    执行代码块2;(可以有多条语句)
}

说明
当条件表达式成立,即执行代码块1,否则执行代码块2。如果执行代码块只有一条语句,则{}可以省略,否则不能省略。

流程图
img_33.png

2.3 多分支

基本语法

if(条件表达式){   
    执行代码块1;(可以有多条语句)     
} else if {   
    执行代码块2;(可以有多条语句)
}    
.....     
else {     
    执行代码块n;
}

说明

  1. 多分枝可以没有else,如果所有的条件表达式都不成立,则一个执行入口都没有。
  2. 如果有else,则所有的条件表达式都不成立,则默认执行else代码块

流程图
img_34.png

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;
}

流程图
img_35.png

使用细节

  1. 表达式数据类型,应和case后的常量类型保持一致,或者是可以自动转成可以相互比较的类型,比如输入的是字符,而常量是int
  2. switch表达式中表达式返回值必须是:byte、short、int、char、enum[枚举]、String
java
//错误示例 double类型不能当作表达式的值
double c = 1.1;
switch(c){
    case 1.1:
        System.out.println("ok");
        break;
}
  1. case子句中的值必须是常量,而不能是变量
  2. default子句是可选的,当没有匹配的case时,执行default
  3. break语句用来在执行完一个case分支后使程序跳出switch语句块;如果没有写break,程序会顺序执行到switch结尾,除非遇到break

switch和if的比较

  1. 如果判断的具体数值不多,而且符合 byte、 short 、int、 char, enum[枚举], String 这 6 种类型。虽然两个语句都可以使用,建议使用switch语句。
  2. 其他情况:对区间判断,对结果为 boolean 类型判断,使用 if,if 的使用范围更广

4.for循环

4.1 基本语法

img_36.png

说明

  1. for关键字表示循环控制
  2. for有四要素: 循环变量初始化、循环条件、循环操作、循环变量迭代
  3. 循环操作这里可以有多条语句,也就是我们要循环执行的代码
  4. 如果循环操作语句只有一条语句,可以省略{},建议不要省略

4.2 执行流程分析

img_37.png

执行流程示例
img_38.pngimg_39.png

4.3 注意事项与细节

  1. 循环条件是返回一个布尔值的表达式
  2. for(;循环判断条件;)中的初始化和变量迭代可以写到其他地方,但是两边的分号不能省略。如果循环变量初始化i放在循环条件的小括号中,i的作用域只能在for循环内,写在for循环外面作用域就会变大。
java
int i = 0;
for (;i < 10;){
    System.out.println("hello world" + i);
    i++;
}
  1. 循环初始值可以有多条初始化语句,但是要求类型一样,并且中间用逗号隔开,循环变量迭代也可以有多条变量迭代语句,中间用逗号隔开
  2. 使用内存分析法分析下面代码
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);
}

img_40.png

5.while循环

基本语法
img_41.png

执行流程
img_42.png

执行案例img_43.pngimg_45.png

  1. 循环条件是返回一个布尔值的表达式
  2. while循环是先判断再执行语句

6.do...while循环

基本语法

循环变量初始化;
do{
循环体(语句);
循环变量迭代;
}while(循环条件);

执行流程
img_44.png

执行案例img_46.pngimg_47.png

  1. 循环条件是返回一个布尔值的表达式
  2. do..while 循环是先执行,再判断, 因此它至少执行一次

注意事项

  1. do while 是关键字
  2. 也有循环四要素, 只是位置不一样
  3. 先执行,再判断,也就是说,一定会至少执行一次
  4. 最后while(循环条件) 后面有一个分号;

7.多重循环控制

  1. 将一个循环放在另一个循环体内,就形成了嵌套循环。其中,for ,while ,do…while 均可以作为外层循环和内层循环。[建议一般使用两层,最多不要超过 3 层, 否则,代码的可读性很差]
  2. 实质上,嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时,才会完全跳出内层循环,才可结束外层的当次循环,开始下一次的循环。
  3. 设外层循环次数为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);
    }
}

img_48.png

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("");
}

img_49.png

9.跳转控制语句-break

break语句用于终止某个语句块的执行,一般使用在switch或者循环[for,while,do-while]中
img_50.png

操作案例

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循环继续执行其他代码");

img_51.png

break标签

  1. break语句出现在多层嵌套的语句块中时,可以通过标签指明要终止哪一层语句块
  2. 标签的使用案例
    情景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循环继续执行其他代码");

img_52.png

情景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循环继续执行其他代码");

img_53.png

10.跳转控制语句continue

  1. continue语句用于结束本次循环,继续执行下一次循环。
  2. continue语句出现在多层嵌套的循环语句体中时,可以通过标签指明要跳过的是哪一层循环,这个和前面的标签的使用的规则一样。 img_54.png

应用案例

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);
}

img_55.png

注意
当在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直接结束该方法,后续代码都不会执行 img_56.png

break
break是跳出循环 继续执行后续代码 img_57.png

continue
continue是跳出本次循环 继续执行下一次循环和后续代码 img_58.png

Released under the MIT License.