Java全栈（二）JavaSE：7.流程控制

声明：本节内容为本人观看“遇见狂神说”Java教学视频后总结，仅供学习参考。

1.顺序结构

package com.oy.流程控制;

public class ShunXunJieGou {
    public static void main(String[] args) {
        System.out.println("Hello1");
        System.out.println("Hello2");
        System.out.println("Hello3");
        System.out.println("Hello4");
    }
}

运行结果如下：

Hello1
Hello2
Hello3
Hello4

2.选择结构

（1）if单选择结构

package com.oy.流程控制;

import java.util.Scanner;

public class OneIf {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入：");
        String s = scanner.nextLine();
        if (s.equals("Hello")){
            System.out.println("输入正确");
        }
        scanner.close();
    }
}

运行结果如下：

请输入：
Hello
输入正确

练习：输入一个年份，判断是否是闰年

• 判断逻辑：普通闰年：公历年份是4的倍数且不是100的倍数（如2004年就是闰年）；世纪闰年：公历年份是整百数的，必须是400的倍数才是闰年（如1900年不是世纪闰年，2000年是世纪闰年）。

package com.oy.流程控制;

import java.util.Scanner;

public class OneIf {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入年份：");
        int year = scanner.nextInt();
        if (year%4==0 && year%100!=0 || year%400==0){
            System.out.println(year+"是闰年");
        }
    }
}

结果如下：

请输入年份：
1896
1896是闰年

（2）if双选择结构

package com.oy.流程控制;

import java.util.Scanner;

public class TwoIf {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩：");
        int cj = scanner.nextInt();
        if (cj >= 60){
            System.out.println("及格");
        }else{
            System.out.println("不及格");
        }
        scanner.close();
    }
}

运行结果如下：

请输入成绩：
80
及格

（3）if多选择结构

注意：按照上下顺序，只要有一个if表达式符合要求，后续的if无论是否满足要求都不会再执行。

package com.oy.流程控制;

import java.util.Scanner;

public class MoreIF {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩：");
        int cj = scanner.nextInt();
        if (cj<=100 && cj>=90){
            System.out.println("优秀");
        }
        else if (cj<90 && cj>=80){
            System.out.println("良好");
        }
        else if (cj<80 && cj>=60){
            System.out.println("及格");
        }
        else if (cj<60 && cj>=0){
            System.out.println("不及格");
        }
        else {
            System.out.println("成绩不合法，请重新输入");
        }
        scanner.close();
    }
}

运行结果如下：

请输入成绩：
76
及格

（4）switch选择结构

• switch就是匹配表达式（expression）的值，当匹配到哪个值时，就执行对应case下的代码。当所有case都未匹配到时，则执行default下的代码。
• switch(表达式)的值的类型，只能是：4种基本数据类型（byte,short,int,char），两种引用数据类型（JDK1.5之后枚举、JDK1.7之后String）
• case后面必须是常量值，而且不能重复
• case后面的值类型必须与表达式的值类型一致，或者能相互转换

package com.oy.流程控制;

public class SwitchDemo1 {
    public static void main(String[] args) {
        char ch = 'C';
        switch (ch){
            case 'A':
                System.out.println("优秀");
                break;
            case 'B':
                System.out.println("良好");
                break;
            case 'C':
                System.out.println("及格");
                break;
            case 'D':
                System.out.println("不及格");
                break;
            default:
                System.out.println("弄啥呢");
        }
    }
}

switch穿透
注意：

• case代码块中，最后的break也可以不要。当不加break则会产生穿透：也就是当匹配到的case未加break时，那么下一个case无论是否匹配都会被执行。如果后续的case仍然未加break，那么会继续向下穿透。直到switch语句结束或者遇到有break语句的case（一般情况下都最好加上break）
• default语句与case语句一样也会被穿透

package com.oy.流程控制;

public class SwitchDemo1 {
    public static void main(String[] args) {
        char ch = 'B';
        switch (ch){
            case 'A':
                System.out.println("优秀");
                break;
            case 'B':
                System.out.println("良好");
            case 'C':
                System.out.println("及格");
                //break;
            case 'D':
                System.out.println("不及格");
                break;
            default:
                System.out.println("弄啥呢");
        }
    }
}

运行结果如下：

良好
及格
不及格

3.循环结构

（1）while循环

package com.oy.流程控制;

public class While {
    public static void main(String[] args) {
        //计算1到100的和
        int i = 0;
        int sum = 0;
        while (i<100) {
            i++;
            sum += i;
        }
        System.out.println(sum);
    }
}

运算结果如下：

5050

（2）do-while循环

package com.oy.流程控制;

public class DoWhile {
    public static void main(String[] args) {
        //计算1到100的和
        int i = 0;
        int sum = 0;
        do {
            i++;
            sum += i;
        } while (i<100);
        System.out.println(sum);
    }
}

运行结果如下：

5050

（3）for循环

练习1：计算0到100之间的奇数和偶数的和

package com.oy.流程控制;

public class ForDemo1 {
    public static void main(String[] args) {
        int jishu_sum = 0;
        int oushu_sum = 0;
        for (int i=0;i<=100;i++){
            if (i%2==0){
                oushu_sum += i;
            }else {
                jishu_sum += i;
            }
        }
        System.out.println(jishu_sum);
        System.out.println(oushu_sum);
    }
}

运算结果如下：

2500
2550

练习2：循环输出1-1000之间能被5整除的数，并且每行输出3个

package com.oy.流程控制;

public class ForDemo2 {
    public static void main(String[] args) {
        int count = 1;
        for (int i=0;i<=1000;i++){
            if (i%5==0){
                System.out.print(i+" "); //print与println的区别：print输出完不会换行，而println输出完会换行
                if (count % 3==0){
                    System.out.println();
                }
                count++;
            }
        }
    }
}

运行结果如下：

0 5 10 
15 20 25 
30 35 40 
45 50 55 
60 65 70 
75 80 85 
90 95 100 
105 110 115 
120 125 130 
135 140 145 
150 155 160 
165 170 175 
180 185 190 
195 200 205 
210 215 220 
225 230 235 
240 245 250 
255 260 265 
270 275 280 
285 290 295 
300 305 310 
315 320 325 
330 335 340 
345 350 355 
360 365 370 
375 380 385 
390 395 400 
405 410 415 
420 425 430 
435 440 445 
450 455 460 
465 470 475 
480 485 490 
495 500 505 
510 515 520 
525 530 535 
540 545 550 
555 560 565 
570 575 580 
585 590 595 
600 605 610 
615 620 625 
630 635 640 
645 650 655 
660 665 670 
675 680 685 
690 695 700 
705 710 715 
720 725 730 
735 740 745 
750 755 760 
765 770 775 
780 785 790 
795 800 805 
810 815 820 
825 830 835 
840 845 850 
855 860 865 
870 875 880 
885 890 895 
900 905 910 
915 920 925 
930 935 940 
945 950 955 
960 965 970 
975 980 985 
990 995 1000 

Process finished with exit code 0

练习3：打印九九乘法表

package com.oy.流程控制;

public class ForDemo3 {
    public static void main(String[] args) {
        for (int i=1;i<=9;i++){
            for (int j=1;j<=i;j++){
                System.out.print(j+"*"+i+"\t");
            }
            System.out.println();
        }
    }
}

运行结果如下：

1*1	
1*2	2*2	
1*3	2*3	3*3	
1*4	2*4	3*4	4*4	
1*5	2*5	3*5	4*5	5*5	
1*6	2*6	3*6	4*6	5*6	6*6	
1*7	2*7	3*7	4*7	5*7	6*7	7*7	
1*8	2*8	3*8	4*8	5*8	6*8	7*8	8*8	
1*9	2*9	3*9	4*9	5*9	6*9	7*9	8*9	9*9	

（4）增强for循环

package com.oy.流程控制;

public class ForDemo4 {
    public static void main(String[] args) {
        int[] num = {10,20,30,40,50};

        //遍历num中的每一项，并赋值给x
        for (int x:num){
            System.out.println(x);
        }
    }
}

运行结果如下：

10
20
30
40
50

4.break和continue

• break：在循环体中使用，用于强制退出循环。
• continue：在循环体中使用，用于退出当前循环，执行下一次循环。注意：不是与退出循环语句，而是结束当前循环，继续下一次循环。
• 注意：如果是嵌套的循环语句，break不能退出所有循环语句。只能退出最近的循环语句。

break练习

package com.oy.流程控制;

public class BreakDemo {
    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            System.out.println(i);
            if (i==10){
                break;
            }
        }
    }
}

运行结果如下：

0
1
2
3
4
5
6
7
8
9
10

continue练习

package com.oy.流程控制;

public class ContinueDemo {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            if (i%2==0){
                continue;
            }
            System.out.println(i);
        }
    }
}

运行结果如下：

1
3
5
7
9

5.三种循环的区别

• 从循环次数角度分析

  • do…while循环至少执行一次循环体语句
  • for和while循环先循环条件语句是否成立，然后决定是否执行循环体，至少执行零次循环体语句

• 从循环变量的生命周期角度分析

  • for循环的循环变量在for()中声明的，在循环语句结束后，不可以被访问；
  • while和do…while循环的循环变量因为在外面声明的，所以while和do…while结束后可以被继续使用的；

• 如何选择

  • 遍历有明显的循环次数（范围）的需求，选择for循环
  • 遍历没有明显的循环次数（范围）的需求，循环while循环
  • 如果循环体语句块至少执行一次，可以考虑使用do…while循环
  • 本质上：三种循环之间是可以互相转换的，都能实现循环的功能

• 三种循环结构都具有四要素：

  • （1）循环变量的初始化表达式
  • （2）循环条件
  • （3）循环变量的修改的迭代表达式
  • （4）循环体语句块

6.嵌套循环

（1）循环嵌套初识

所谓嵌套循环，是指一个循环的循环体是另一个循环。比如for循环里面还有一个for循环，就是嵌套循环。总共的循环次数=外循环次数*内循环次数。当然可以是三种循环任意互相嵌套。

练习：打印5行5列的*

package com.oy.流程控制;

public class 练习2 {
    public static void main(String[] args) {
        for(int i=1;i<=5;i++){
            for(int j=1;j<=5;j++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

结果如下：

*****
*****
*****
*****
*****

结论：

• 外层循环控制行数，内层循环控制列数。
• 外层循环执行一次，内层循环要从头到尾执行一遍

（2）循环嵌套的break

• 普通的break只能结束所在层的循环。例如：break是在内层循环的循环体内，那么break只能结束内层循环，不能结束外层循环。
• 如果想使用内存循环的break来结束外层循环，可以给break加上label（标签）
• 

（3）循环嵌套的continue

• 普通的continue只能作用于所在层的循环。例如：continue是在内层循环的循环体内，那么continue只能作用于内层循环，不能作用于外层循环。
• 如果想使用内存循环的continue来作用于外层循环，可以给continue加上label（标签）
• 

练习

1.猜数字

• 需求：随机生成一个1到100以内的数，猜数字游戏从键盘输入数，如果大了提示，大了，如果小了，提示小了，如果对了，就不再猜了，并统计一共猜了多少次
• 提示：
  • （1）Java中使用Math.random()生成0.0到1.0的随机数字
  • （2）使用Math.random*(m-n+1)+n生成n到m之间的随机数

package com.oy.流程控制;

import java.util.Scanner;
import java.lang.Math;

public class 练习1 {
    public static void main(String[] args) {
        //生成随机数
        int num = (int)Math.random()*(100-1+1)+1;
        while (true){
            // 获取键盘输入的数组
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入一个数字：");
            int myNum = scanner.nextInt();
            if (myNum>num){
                System.out.println("不对哦！猜大了");
            }else if (myNum<num){
                System.out.println("不对哦！猜小了");
            }else {
                System.out.println("恭喜！猜对了");
                break;
            }
        }
        System.out.println("Game Over");
    }
}

2.打印直角三角形

需求：运行程序输出如下图案

*
**
***
****
*****

package com.oy.流程控制;

public class 练习2 {
    public static void main(String[] args) {
        for(int i=1;i<=5;i++){
            for(int j=1;j<=i;j++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

运行结果如下：

*
**
***
****
*****

3.打印平行四边形

需求：打印如下图形

    *******
   *******
  *******
 *******
*******

分析：我们可以理解为打印下面这种图像，只需要将-转化为空格就行

----*******
---*******
--*******
-*******
 *******

package com.oy.流程控制;

public class 练习2 {
    public static void main(String[] args) {
        for(int i=1;i<=5;i++){
            //打印空格
            for(int j=1;j<=5-i;j++){
                System.out.print(" ");
            }
            //打印*
            for(int j=1;j<=7;j++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

运行效果如下：

    *******
   *******
  *******
 *******
*******

4.打印菱形

需求：打印如下图形

         *
        * *
       * * *
      * * * *
     * * * * *
      * * * *
       * * *
        * *
         *

分析：将图形分为上下两部分，并把-转化为空格

上半部分：
--------*
-------* *
------* * *
-----* * * *
----* * * * *
下半部分：
-----* * * *
------* * *
-------* *
--------*

package com.oy.流程控制;

public class 练习2 {
    public static void main(String[] args) {
        //打印上半部分图形
        for(int i=1;i<=5;i++){
            //打印空格
            for(int j=1;j<=9-i;j++){
                System.out.print(" ");
            }
            //打印*
            for(int j=1;j<=i;j++){
                System.out.print("* ");
            }
            System.out.println();
        }

        //打印下半部分图形
        for(int i=1;i<=4;i++){
            //打印空格
            for(int j=1;j<=4+i;j++){
                System.out.print(" ");
            }
            //打印*
            for(int j=1;j<=5-i;j++){
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

运行效果如下：

        * 
       * * 
      * * * 
     * * * * 
    * * * * * 
     * * * * 
      * * * 
       * * 
        * 

总结：要确认空格和*与行数的关系。