【Java基本语法-流程控制】

流程控制的概念

流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组
合成能完成一定功能的小逻辑模块。
> 其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即：
①顺序结构
程序从上到下逐行地执行，中间没有任何判断和跳转
②分支结构
根据条件，选择性地执行某段代码。有if…else和switch-case两种分支语句。
③循环结构
根据循环条件，重复性的执行某段代码。有while、do…while、for三种循环语句。
☆注：JDK1.5提供了foreach循环，方便的遍历集合、数组元素。

分支结构中的if-else

分支结构中的if-else（条件判断结构）

        第一种：
            if(条件表达式){
                执行表达式;
            }


        第二种：二选一
            if(条件表达式){
                执行表达式1;
            }else{
                执行表达式2;
            }


         第三种:n选一
            if(条件表达式1){
                执行表达式1;
            }else if(条件表达式2){
                执行表达式2;
            }else if(条件表达式3){
                执行表达式3;
            }.....
             .....
            else{
                执行表达式n；
            }

		//举例1：
        int hearBeats = 179;
        if (hearBeats < 60 || hearBeats > 100) {
            System.out.println("需要进一步检查");
        }
        System.out.println("检查结束");

        //举例2：
        int age = 23;
        if (age < 18) {
            System.out.println("你还可以看动画片");
        } else {
            System.out.println("你可以看成人电影了");
        }

        //举例3：
        if (age < 0) {
            System.out.println("您输入的数据非法");
        } else if (age < 18) {
            System.out.println("青少年时期");
        } else if (age < 35) {
            System.out.println("青壮年时期");
        } else if (age < 60) {
            System.out.println("中年时期");
        } else if (age < 120) {
            System.out.println("老年时期");
        } else {
            System.out.println("您是要成仙啊");
        }

☆注意：
1、else结构是可选的
2、针对于条件表达式：
>如果多个条件表达式之间是“互斥”关系（或没有交集的关系），哪个判断和执行语句声明在上面还是下面，无所谓
>如果多个条件表达式之间有交集的关系，需要根据实际情况，考虑清楚应该将哪个结构声明在上面。
>如果多个条件表达式之间有包含的关系，通常情况下，需要将范围小的声明在范围大的上面，否则范围小的就没机会执行了。

	   Scanner scan = new Scanner(System.in);

        System.out.println("请输入成绩：（0-100）");
        int score = scan.nextInt();
        if (score == 100) {
            System.out.println("奖励一辆BMW");
        } else if (score > 80) {
            System.out.println("奖励一台iphone");
        } else if (score >= 60) {
            System.out.println("奖励一个iPad");
        } else {                                  //这里的else结构也可以注释掉。
            System.out.println("什么也没有");
        }

        /*
        System.out.println("请输入成绩：（0-100）");
        int score = scan.nextInt();
        if(score == 100){
            System.out.println("奖励一辆BMW");
        }else if (score >= 60){                 //此时范围大的>=60在上面，范围小的>80在下面，导致程序运行到>=60后，判断成功，执行“奖励一个iPad”
                                                //就结束了if-else结构。而本应该奖励的iphone却没有了。
            System.out.println("奖励一个iPad");
        }else if(score > 80 ){
            System.out.println("奖励一台iphone");
        }else{                                  //这里的else结构也可以注释掉。
            System.out.println("什么也没有");
        }



        正确示范：
        System.out.println("请输入成绩：（0-100）");
        int score = scan.nextInt();
        if(score == 100){
            System.out.println("奖励一辆BMW");
        }else if(score > 80 && score <= 90 ){       //让条件表达式更严谨
            System.out.println("奖励一台iphone");
        }else if (score >= 60 && score <= 80){      //让条件表达式更严谨
            System.out.println("奖励一个iPad");
        }else{
            System.out.println("什么也没有");
        }

if-else结构可以互相嵌套使用
从小到大排列三个数字

 //☆注意，开发中什么情况都不要省略{},如果没有加{}，可能导致if(){}变成一条语句，而else此时会跟最近的if形成结构！
        int x = 4;
        int y = 1;
        if (x > 2)       //if()没有加{}，导致如果条件表达式不满足x>2,就不会执行else语句，
            // 并且此时else就近原则，和第二个if形成了if-else结构。
            if (y > 2)
                System.out.println(x + y);//条件表达式不满足y>2,执行了else语句。
            else
                System.out.println("x是" + x);//x是4

分支结构：switch-case

分支结构：switch-case结构

        结构：
        switch(表达式){
        case 常量1:
        语句1;
        // break;
        case 常量2:
        语句2;
        // break; … …
        case 常量N:
        语句N;
        // break;
        default:
        语句;
        // break;
        }

switch(表达式)中表达式的值必须是下述几种类型之一：byte，short，
char，int，枚举 (jdk 5.0)，String (jdk 7.0)；
case子句中的值必须是常量，不能是变量名或不确定的表达式值；
同一个switch语句，所有case子句中的常量值互不相同；
break语句用来在执行完一个case分支后使程序跳出switch语句块；如果没有break，程序会顺序执行到switch结尾
default子句是可任选的。同时，位置也是灵活的。当没有匹配的case时，执行default

if和switch语句很像，具体什么场景下，应用哪个语句呢？
如果判断的具体数值不多，而且符合byte、short 、char、int、String、枚举等几
种类型。虽然两个语句都可以使用，建议使用switch语句。因为效率稍高。
其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。
也就是说，使用switch-case的，都可以改写为if-else。反之不成立。

		int number = 1;
        switch (number) {
            case 0:
                System.out.println("zero");
            case 1:
                System.out.println("one");
            case 2:                             //表达式匹配到case 2：开始执行System.out.println("two");
                System.out.println("two");
            case 3:
                System.out.println("three");    //因为case 2：没有break，所以调用执行语句后，继续向下执行System.out.println("three");
            case 4:
                System.out.println("four");     //直到调用执行了System.out.println("four");碰到了break，才没有继续执行default中的执行语句
                break;                          //遇到了case 4：中的break;停止了继续向下执行。
            default:
                System.out.println("other");
        }
         /*
            如下两种编译不通过：
            情况一、
            boolean isHandsome = true;
            switch(isHandsome){                      //编译错误，不能用boolean类型的表达式
                case true:
                    System.out.println("我好帅啊");
                    break;
                case false:
                    System.out.println("我好帅啊");
                    break;
            }default:
                    System.out.println("输入有误");


            情况二、
                int age = 10;
                switch(age){
                    case age > 18:                  //case 只能使用常量，不能使用范围或变量名等
                    System.out.println("成年了");
                    break;
                }default:
                    System.out.println("未成年");

①根据switch表达式中的值，依次匹配各个case中的常量，一旦匹配成功，则进入相应的case结构中，调用其执行语句。
当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case结构末尾结束为止。
②break，可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出结构。
③switch结构中的表达式， 只能是如下6种数据类型之一：byte、short、char、int、枚举类型、String类型
④case之后只能声明常量，不能声明范围或变量名。
⑤break关键字是可选的。
⑥default：相当于if-else结构中的else。default结构是可选的，而且位置是灵活的。

循环结构

循环结构
>在某些条件满足的情况下，反复执行特定代码的功能
循环语句分类
>for 循环
>while 循环
>do-while 循环

        循环语句的四个组成部分
        >初始化部分(init_statement)
        >循环条件部分(test_exp)
        >循环体部分(body_statement)
        >迭代部分(alter_statement)

for循环

for循环结构的使用：
一、循环结构的4个要素
①初始化条件
②循环条件 —>是boolean类型
③循环体
④迭代条件
二、for循环的结构

            for（①;②;④）{
                ③;
            }
            
            执行过程：①-②-③-④-②-③-④.....-②

 			//输出5次Hello world。
            System.out.println("Hello World");
            System.out.println("Hello World");
            System.out.println("Hello World");
            System.out.println("Hello World");
            System.out.println("Hello World");

            //用for循环来输出5次Hello World。
            for(int i = 0; i< 6 ; ++i){
                System.out.println("Hello World");
            }

            //练习：
            int num = 1;
            for(System.out.println('a');num<=3;System.out.println('c'),++num){
                System.out.println('b');
            }//输出结果为：a-b-c-b-c-b-c


            //遍历100里的所有偶数，输出他们的合和个数
            int sum = 0;
            int count = 0;
            for(int i=1;i<=100;++i){
                if(i%2 == 0){
                    System.out.println(i);
                    sum += i;
                    ++count;
                }
            }
            System.out.println(sum);
            System.out.println(count);

while循环

while循环结构的使用:

        一、循环结构的4个要素
            ①初始化条件
            ②循环条件 --->是boolean类型
            ③循环体
            ④迭代条件

        二、语法格式

            ①初始化部分
            while(②循环条件){
                ③循环体部分;
                ④迭代部分;
            }

            >执行过程：
            ①-②-③-④-②-③-④-②-③-④-...-②

            说明：
            >注意不要忘记声明④迭代部分。否则，循环将不能结束，变成死循环。
            >我们写程序要避免出现死循环。
            >for循环和while循环可以相互转换
                区别：for循环和while循环的初始条件部分的作用范围是不同的。

 			//遍历100以内的所有偶数
            int i =1;
            while(i<=100){
                if(i%2 == 0){
                    System.out.println(i);
                }
                ++i;
            }

do-while循环

do-while循环结构的使用

            一、循环结构的4个要素
            ①初始化条件
            ②循环条件 --->是boolean类型
            ③循环体
            ④迭代条件


            二、语法格式

            ①初始化部分
            do{
                ③循环体部分;
                ④迭代部分;

            }while(②循环条件);

            执行过程：
            ①-③-④-②-③-④-②-③-④-...②

            说明：
            1、do-while循环至少执行一次循环体
            2、开发中，使用for和while更多一些，较少使用do-while。

			//遍历100内的所有偶数，计算他们的和与个数。
                int j = 1;
                int sum1 = 0;
                int count1 = 0;

                do{
                    if(j%2== 0){
                        System.out.println(j);
                        sum1 += j;
                        ++count1;
                    }
                    ++j;
                }while(j<=100)  ;

                System.out.println(sum1);
                System.out.println(count1);

for和while的无限循环

        for和while的无限循环:

        说明
        1、不在循环条件部分限制次数的结构：for(;;){}、while(true){}
        2、结束循环的条件有几种方式？
            方式一：循环条件部分返回false。
            方式二：在循环体中，执行break。

 //例题：从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序。

            Scanner scan2 = new Scanner(System.in);

            int positiveNumber = 0;//记录正数的个数
            int negativeNumber = 0;//记录负数的个数

            while(true){                        //无限循环条件
                int numm = scan2.nextInt();
                if(numm>0){                     //判断numm的正负情况
                    ++positiveNumber;
                }else if(numm<0){
                    ++negativeNumber;
                }else{
                    break;                      //一旦执行break，跳出循环
                }
            }

                System.out.println(positiveNumber);
                System.out.println(negativeNumber);

嵌套循环的使用

嵌套循环的使用
1、嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中，就构成了嵌套循环
2、
外层循环：循环结构B
内存循环：循环结构A
3、
①内层循环结构遍历一遍，只相当于外层循环循环体执行一次
②假设外层循环需要执行m次，内层循环需要执行n次，此时内层循环的循环体一个执行了m*n次。

/*例题：

            打印一个
             ******
             ******
             ******
             ******
            */

        for (int i1 = 0; i1 <=3 ; i1++) {
            for (int j1 = 0; j1 <=5 ; j1++) {
                System.out.print('*');
            }
            System.out.print('\n');

        }

            /*例题：

            打印一个
                 *
                * *
               * * *
              * * * *
             * * * * *
              * * * *
               * * *
                * *
                 *
            */

        for (int i1 = 1; i1 <=5 ; i1++) {
            for (int k = 1; k <=5-i1 ; k++) {
                System.out.print(' ');
            }
            for (int j1 = 1; j1 <= i1; j1++) {

                System.out.print('*');
                System.out.print(' ');
            }
            System.out.print('\n');

        }

        for (int i1 = 1; i1 <=4 ; i1++) {
            for (int k = 1; k <=i1 ; k++) {
                System.out.print(' ');
            }
            for (int j1 = 1; j1 <=5-i1 ; j1++) {

                System.out.print('*');
                System.out.print(' ');
            }
            System.out.print('\n');
        }

break和continue关键字的使用

break和continue关键字的使用

                    使用范围         循环中使用(不同点)         相同点

        break:      switch-case
                    循环结构中       结束当前循环       关键字后面不能声明执行语句
        continue:   循环结构中       结束当次循环       关键字后面不能声明执行语句

	for (int k = 1; k <=10 ; k++) {
            if(i%4==0){
                //break;  //123
                continue; //123567910
            }
            System.out.println(i);
        }

        //标签：

        label:for (int k = 1; k <4 ; k++) {     //label：是标签，可以自己取名，如：L: 、 ABC：等
            for (int l = 1; l <=10 ; l++) {
                if(l%4==0){
                    //break;//默认跳出包裹此关键字最近的一层循环。
                    //continue; 同理
                    //break label;//结束指定标识的一层循环结构，标识可以自己取名。
                    continue label;//结束指定标识的一层循环结构的当次循环，标识可以自己取名。
                }
                System.out.println(i);
            }

        }