03 流程控制语句

第1章 流程控制

1.1 概述

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

1.2 分类

顺序结构

• 没有特定的语法结构，按照代码的先后顺序，依次执行。

分支结构

• 判断语句：if、if...else、if...else if...else
• 选择语句：switch

循环结构

• 循环语句：for、 while、do…while

第2章 判断语句

2.1 判断语句1–if

格式：

if (关系表达式) {
	语句体;
}

执行流程：

1.先判断关系表达式，结果是true就执行语句体，如果是false就不执行语句体。

2.继续执行其他语句。

public class IfDemo {
    public static void main(String[] args) {
        System.out.println("开始");
        //定义两个变量
        int a = 10;
        int b = 20;
        //需求：判断a和b的值是否相等。如果相等，就在控制台输出：a等于b
        if(a == b) {
        	System.out.println("a等于b");
        }
        //需求：判断a和c的值是否相等。如果相等，就在控制台输出：a等于c
        int c = 10;
        if(a == c) {
        	System.out.println("a等于c");
        }
        System.out.println("结束");
    }
}

2.2 判断语句2–if…else

格式：

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

执行流程：

1.计算关系表达式的值，关系表达式的值为true，执行语句体1。否则，执行语句体2。

2.继续执行后面的语句内容。

public static void main(String[] args){
    // 判断给定的数据是奇数还是偶数
    int a = 1;
    if(a % 2 == 0) {
    	System.out.println("a是偶数");
    } else {
    	System.out.println("a是奇数");
    }
    System.out.println("结束");
}

练习：实现三元运算符的功能。

public static void main(String[] args) {
    int a = 10;
    int b = 20;
    //定义变量，保存a和b的较大值
    int c;
    if(a > b) {
    	c = a;
    } else {
    	c = b;
    }
    
    //可以上述功能改写为三元运算符形式
    c = a > b ? a:b;
}

2.3 判断语句3–if…else if…else

格式：

if (关系表达式1) {
	语句体1;
} else if (关系表达式2) {
	语句体2;
}
…
else {
	语句体n+1;
}

执行流程：

1.计算关系表达式1的值，值为true就执行语句体1。否则，计算关系表达式2的值。值为true就执行语句体2；否则，计算表达式3的值…若没有任何关系表达式为true，就执行语句体n+1。

2.继续执行后面的语句内容。

public static void main(String[] args) {
    // x和y的关系满足如下：
    // x>=3，y = 2x + 1;
    //‐1<=x<3，y = 2x;
    // x<=‐1，y = 2x – 1;
    // 根据给定的x的值，计算出y的值并输出。
    // 定义变量
    int x = 5;
    int y;
    if (x>= 3) {
    	y = 2 * x + 1;
    } else if (x >= ‐1 && x < 3) {
    	y = 2 * x;
    } else {
    	y = 2 * x ‐ 1;
    }
    System.out.println("y的值是："+y);
}

练习：指定考试成绩，判断学生等级。

• 90-100 优秀
• 80-89 好
• 70-79 良
• 60-69 及格
• 60以下 不及格

public static void main(String[] args) {
    int score = 100;
    if(score<0 || score>100){
    	System.out.println("你的成绩是错误的");
    }else if(score>=90 && score<=100){
    	System.out.println("你的成绩属于优秀");
    }else if(score>=80 && score<90){
    	System.out.println("你的成绩属于好");
    }else if(score>=70 && score<80){
    	System.out.println("你的成绩属于良");
    }else if(score>=60 && score<70){
    	System.out.println("你的成绩属于及格");
    }else {
    	System.out.println("你的成绩属于不及格");
    }
}

第3章 选择语句

3.1 选择语句–switch

格式：

switch (表达式) {
    case 1:
        语句体1;
        break;
    case 2:
        语句体2;
        break;
    ...
    default:
        语句体n+1;
        break;
}

switch语句中，表达式的数据类型，可以是 byte，short，int，char，enum（枚举），JDK7后可以接收 字符串。

执行流程：

1.计算出表达式的值。

2.依次和case比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。

3.若所有的case都和表达式的值不匹配，执行default语句体部分，然后程序结束掉。

public static void main(String[] args) {
    //定义变量，判断是星期几
    int weekday = 6;
    //switch语句实现选择
    switch(weekday) {
        case 1:
            System.out.println("星期一");
            break;
        case 2:
            System.out.println("星期二");
            break;
        case 3:
            System.out.println("星期三");
        	break;
        case 4:
            System.out.println("星期四");
            break;
        case 5:
            System.out.println("星期五");
            break;
        case 6:
            System.out.println("星期六");
            break;
        case 7:
            System.out.println("星期日");
            break;
        default:
            System.out.println("你输入的数字有误");
            break;
    }
}    

3.2 case的穿透性

在switch语句中，如果case的后面不写break，将出现穿透现象，也就是不会在判断下一个case的值，直接向后运行，直到遇到break，或者整体switch结束。

public static void main(String[] args) {
    int i = 5;
    switch (i){
        case 0:
            System.out.println("执行case0");
            break;
        case 5:
        	System.out.println("执行case5");
        case 10:
        	System.out.println("执行case10");
        default:
        	System.out.println("执行default");
    }
}

上述程序中，执行 case5 后，由于没有break语句，程序会一直向后走，不会在判断case，也不会理会break，直接运行完整体switch。

第4章 循环语句

4.1 循环概述

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

4.2 循环语句1–for

格式：

for(初始化语句①; 条件判断语句②; 条件控制语句④){
	循环体语句③;
}

执行流程：

1.执行顺序：①②③④—>②③④—>②③④…直到②不满足为止。

2.①负责完成循环变量初始化。

3.②负责判断是否满足循环条件，不满足则跳出循环。

4.③具体执行的语句。

5.④循环后，循环条件所涉及变量的变化情况。

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

    //需求：输出数据5-1
    for(int i=5; i>=1; i--) {
        System.out.println(i);
    }
}

练习：

1.需求：求1-5之间的数据和，并把求和结果在控制台输出。

public static void main(String[] args) {
    //1.定义求和变量保存求和的结果，初始值为0
    int sum = 0;

    //2.循环遍历1-5，并累加到变量sum中
    for(int i=1; i<=5; i++) {
        sum += i;
    }

    //3.循环完毕，打印最终数据
    System.out.println("1-5之间的数据和是：" + sum);
}

求和变量必须定义在循环外部，在循环内部计算出的数据将是错误的。

2.需求：求1-100之间的偶数和，并把求和结果在控制台输出 。

public static void main(String[] args) {
    int sum = 0;

    for(int i=1; i<=100; i++) {
        //判断是否是偶数
        if(i%2 == 0) {
            sum += i;
        }
    }

    System.out.println("1-100之间的偶数和是：" + sum);
}

3.需求：在控制台输出所有的水仙花数（三位数。个位、十位、百位的数字立方和等于原数）。例如：153，3 * 3 * 3 + 5 * 5 * 5 + 1 * 1 * 1 = 153

public static void main(String[] args) {
    //1.遍历所有的三位数，从100开始，到999结束
    for(int i=100; i<1000; i++) {
        //2.获取每一个三位数的个位，十位，百位
        int ge = i%10;
        int shi = i/10%10;
        int bai = i/100%10;
        
        //3.按规则判断出水仙花数，并输出
        if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
            System.out.println(i);
        }
    }
}

注意：

1.求数字指定位的值：先用整除操作将要求的数字移动到个位上，再对10取余。

2."a^{3"不表示立方，"}"表示异或。

4.需求：统计“水仙花数”一共有多少个，并在控制台输出个数。

public static void main(String[] args) {
    //1.定义计数器变量保存“水仙花数”的数量，初始值为0
    int count = 0;

    //2.遍历所有的三位数，三位数从100开始，到999结束
    for(int i=100; i<1000; i++) {
        //3.获取每一个三位数的个位，十位，百位
        int ge = i%10;
        int shi = i/10%10;
        int bai = i/100%10;

        //4.满足条件不再输出，更改为修改count的值，使count+1
        if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
            count++;
        }
    }
    //5.输出结果
    System.out.println("水仙花共有：" + count + "个");
}

计数器变量定义的位置，必须在循环外部。

4.3 循环语句2–while

格式：

初始化语句①;
while (条件判断语句②) {
    循环体语句③;
    条件控制语句④;
}

执行流程：

1.执行顺序：①②③④—>②③④—>②③④…直到②不满足为止。

2.①负责完成循环变量初始化。

3.②负责判断是否满足循环条件，不满足则跳出循环。

4.③具体执行的语句。

5.④循环后，循环变量的变化情况。

public static void main(String[] args) {
    //while循环实现打印10次HelloWorld
    //定义初始化变量
    int i = 1;
    //循环条件<=10
    while(i<=10){
        System.out.println("HelloWorld");
        //步进
        i++;
    }
}

练习：世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米)，假如我有一张足够大的纸，它的厚度是0.1毫米。请问，折叠多少次，可以折成珠穆朗玛峰的高度?

public class WhileTest {
    public static void main(String[] args) {
        //1.定义变量存放折叠次数，初始值为0
        int count = 0;
        
        //2.定义纸张厚度
        double paper = 0.1;
        
        //3.定义珠峰的高度
        int zf = 8844430;
        
        //4.使用while循环（折叠次数未知）进行反复折叠，直到纸张厚度大于珠峰，
        while(paper <= zf) {
            //4.1每次纸张折叠，纸张的厚度加倍
            paper *= 2;
            //4.2进行累加，对应折叠了多少次
            count++;
        }
        System.out.println("需要折叠：" + count + "次");
    }
}

4.4 循环语句3–do…while

格式：

初始化语句①;
do {
    循环体语句③;
    条件控制语句④;
}while(条件判断语句②);

执行流程：

1.执行顺序：①③④—>②③④—>②③④…直到②不满足为止。

2.①负责完成循环变量初始化。

3.②负责判断是否满足循环条件，不满足则跳出循环。

4.③具体执行的语句。

5.④循环后，循环变量的变化情况。

//需求：在控制台输出5次"HelloWorld"。
public class DoWhileDemo {
    public static void main(String[] args) {
        //for循环实现
        for(int i=1; i<=5; i++) {
        	System.out.println("HelloWorld");
        }

        //while循环实现
        int j = 1;
        while(j<=5) {
            System.out.println("HelloWorld");
        	j++;
        }
        
        //do...while循环实现
        int j = 1;
        do {
            System.out.println("HelloWorld");
            j++;
        }while(j<=5);
    }
}

4.5 循环语句的区别

1.for 循环和while 循环先判断条件是否成立，然后决定是否执行循环体（先判断后执行）。

2.do...while 循环开始先执行一次循环体，然后判断条件是否成立、是否继续执行循环体（先执行后判断）。

3.条件控制语句所控制的自增变量，归属 for 循环的语法结构中，在 for 循环结束后，就不能再次被访问到了。但对于 while 循环来说不归属其语法结构中，在 while 循环结束后，该变量还可以继续使用。

4.6 死循环

死循环：循环中的条件永远为true，死循环的是永不结束的循环。

for(;;){}

while(true){}

do {} while(true);

后期的开发中，会出现使用死循环的场景，例如：当需要读取用户输入的输入，但是用户输入多少数据我们并不清楚，也只能使用死循环，当用户不想输入数据了，就可以结束循环了，如何去结束一个死循环呢，就需要使用到跳出语句了。

4.7 跳转控制语句

break：用于终止switch语句或者结束循环。

public static void main(String[] args) {
    for (int i = 1; i<=10; i++) {
        //需求:打印完两次HelloWorld之后结束循环
        if(i == 3){
        	break;
        }
        System.out.println("HelloWorld"+i);
    }
}

continue：用于跳过本次循环，继续下次循环。只能在循环中使用。

public static void main(String[] args) {
    for (int i = 1; i <= 10; i++) {
        //需求:不打印第三次HelloWorld
        if(i == 3){
            continue;
        }
        System.out.println("HelloWorld"+i);
    }
}

4.8 循环嵌套

循环嵌套：在循环中，继续定义循环。总共的循环次数=外循环次数*内循环次数。

格式：

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

执行流程：

1.执行顺序：①②③④⑤⑥—>④⑤⑥—>⑦②③④⑤⑥>④⑤⑥

2.比如跳绳：一共跳5组，每组跳10个。5组就是外循环，10个就是内循环。

注意：

1.整个内循环，就是外循环的一个循环体，内部循环体没有执行完毕，外循环是不会继续向下执行的。

2.外循环一次，内循环多次。

练习：

1.需求：打印24小时及每个小时60分钟。

public static void main(String[] args) {
    //1.外循环控制小时的范围
    for (int hour = 0; hour < 24; hour++) {
    	//2.内循环控制分钟的范围
        for (int minute = 0; minute < 60; minute++) {
            System.out.println(hour + "时" + minute + "分");
   		}
    	System.out.println("--------");
    }
}

2.需求：使用嵌套循环，打印5*8的矩形。

public static void main(String[] args) {
    //5*8的矩形，打印5行*号，每行8个
    //外循环5次，内循环8次
    for(int i = 0; i < 5; i++){
        for(int j = 0; j < 8; j++){
            //不换行打印星号
            System.out.print("*");
        }
        //内循环打印8个星号后，需要一次换行
        System.out.println();
    }
｝