前言

  本文介绍Java中对于代码中执行语句执行顺序的一个基本内容，详细介绍了分支结构和循环结构的使用。

1 流程控制概述

定义：流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。

流程控制的类型

控制语句分为三类：顺序、选择和循环。（三种流程控制语句就能表示所有的事情）
  “顺序结构”代表“先执行a，再执行b”的逻辑。
  “条件判断结构”代表“如果…，则…”的逻辑。
  “循环结构”代表“如果…，则再继续…”的逻辑。

2 分支结构

2.1 if语句

分支可以分为三种（单分支，双分支和多分支）

逻辑结构图

   ↓ 单分支：

   ↓ 双分支：

  ↓ 多分支：

语法结构

  if( ){ } ;//单分支
  if( ){ }else{ };//双分支
  if( ){ }else if( ){ }else if( ){ }.....else{ };//多分支
1
2
3

说明：

• 括号中是条件表达式，这个表达式的结果是布尔值：要么是false，要么是true
• 如果括号中表达式返回结果是true，那么就执行{}中代码，否则不执行
• {}可以省略不写,但是一旦省略，这个if就只负责后面的一句话

2.2 switch语句

逻辑结构图

语法结构

switch (表达式) {
    case 值1:
         语句序列1;
         [break];
    case 值2:
         语句序列2;
         [break];
        … … …      … …
    [default:默认语句;]
}
1
2
3
4
5
6
7
8
9
10

说明:

• switch语句会根据表达式的值从相匹配的case标签处开始执行，一直执行到break语句处或者是switch语句的末尾。
• 如果表达式的值与任一case值不匹配，则进入default语句（如果存在default语句的情况）。根据表达式值的不同可以执行许多不同的操作。

代码实例

/**
 * switch
 **/
public class demo1 {
    public static void main(String[] args) {
         /*
            实现一个功能：
            根据给出的学生分数，判断学生的等级：
            >=90  -----A
            >=80  -----B
            >=70  -----C
            >=60  -----D
            <60   -----E

            用if分支：
            if(score>=90){

            }else if(score>=80){

            }
         */
        //1.给出学生的成绩：
        int score = 167;
        //2.根据成绩判断学生的等级：
        switch(score/10){
            case 10 :
            case 9 : System.out.println("A级");break;
            case 8 : System.out.println("B级");break;
            case 7 : System.out.println("C级");break;
            case 6 : System.out.println("D级");break;
            default:System.out.println("成绩错误");break;
            case 5 :
            case 4 :
            case 3 :
            case 2 :
            case 1 :
            case 0 : System.out.println("E级");break;
        }
        //default分支可以写在任意的位置上，但是如果没有在最后一行，后面必须加上break关键字，如果在最后一行的话，break可以省略
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

3 循环结构

3.1 while语句

逻辑结构图

语法结构

while (布尔表达式) {
            循环体;
}
1
2
3

代码实例: 计算1加到100的和

/**
 * while
 **/
public class demo2 {
    public static void main(String[] args) {
        int num = 1;
        //2.定义一个求和变量，用来接收和：
        int sum = 0;
        while(num<=100){ // [2]条件判断
            sum += num; // [3]循环体
            num++; // [4]迭代
        }
        //3.输出和
        System.out.println(sum);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3.2 do{}while{}语句

逻辑结构图

语法结构

do {
            循环体;
    } while(布尔表达式) ;
1
2
3

代码实例: 计算1加到100的和

/**
 * do while
 **/
public class demo3 {
    public static void main(String[] args) {
        //1+2+3+4+...100
        //while方式:
                /*
                int i = 101;
                int sum = 0;
                while(i<=100){
                        sum += i;
                        i++;
                }
                System.out.println(i);//101
                System.out.println(sum);//0
                */
        //do-while方式：

        int i = 101;
        int sum = 0;
        do{
            sum += i;
            i++;
        }while(i<=100);//一定要注意写这个分号，否则编译出错
        System.out.println(i); // 102
        System.out.println(sum); // 101
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

while和do-while的区别

  while: 先判断，再执行
  do-while: 先执行，再判断—》至少被执行一次，从第二次开始才进行判断

3.3 for语句

逻辑结构图

语法结构

for (初始表达式; 布尔表达式; 迭代因子) {
          循环体;
}
1
2
3

  处置表达式：for循环在第一次反复之前要进行初始化，即执行初始表达式；
  布尔表达式：随后，对布尔表达式进行判定，若判定结果为true，则执行循环体，否则，终止循环；
  迭代因子：最后在每一次反复的时候，进行某种形式的“步进”，即执行迭代因子。

代码实例：1加到100：

/**
 * for
 **/
public class demo4 {
    public static void main(String[] args) {
        //1+2+3+..+100
        //for:
        int sum = 0;
        int i;
        for(i = 1;i<=100;i++){
            sum += i;
        }
        System.out.println(sum);
        System.out.println(i);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

• 死循环：写了如下代码会一直执行下去

for(;;){}
                
while(true){}
                
do{    
}while(true);
1
2
3
4
5
6

3.4 break，continue，return对循环结构的作用

1. break可以在任何循环语句的主体部分控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。
2. continue 语句用在循环语句体中，用于终止某次当前循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。
3. return的作用跟循环无关，而是结束当前所在方法的执行。

/**
 * break，continue，return对循环结构的作用
 **/
public class demo5 {
    public static void main(String[] args) {
        //break的作用：停止最近的循环
        //离break最近的for循环退出
        for(int i=1;i<=100;i++){
            System.out.println(i);
            if(i==36){
                break;//1-36
            }
        }

        //离break最近的while循环退出，而不是外面的for循环
        for(int i=1;i<=100;i++){
            System.out.println(i);
            while(i==36){
                break;
            }
        }

        //break还可以带标签使用
        outer:     //----> 定义标签结束的位置
        for(int i=1;i<=100;i++){
            System.out.println(i);
            while(i==36){
                break outer;    //----> 根据标签来结束循环
            }
        }

        //continue的作用：结束本次离它近的循环，继续下一次循环
        for(int i=1;i<=100;i++){
            if(i==36){
                continue;//结果是1-100中间没有36
            }
            System.out.println(i);
        }

        for(int i=1;i<=100;i++){
            while(i==36){
                System.out.println("------");
                continue; //1-35+死循环
            }
            System.out.println(i);
        }
        //continue同样可以带标签使用
        outer:
        for(int i=1;i<=100;i++) {
            while (i == 36) {
                continue outer;  //1-100没有36
            }
            System.out.println(i);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56