重学Java 6 流程控制语句

我与我，至死不渝

——24.1.15

模块重点：

①会使用Scanner和Random

②会使用switch以及知道case的穿透性

③会使用if

④会使用for循环，while循环，嵌套循环

一、键盘录入_Scanner

1.概述：是Java定义好的一个类

2.作用：将数据通过键盘录入的形式放到代码中参与运行

3.位置：java.util

4.使用：

①导包：通过导包的方式找到要使用的类 -> 导包位置：类上

import java.util.Scanner; -> 导入包：明确使用的是哪个包下的哪个类的

        ②创建对象

Scanner 变量名 = new Scanner(System.in);

        ③调用方法，实现键盘录入

变量名.nextInt()        输入整数int型的

变量名.next() 输入字符串String型的

1.Scanner键盘录入练习

package Better;

import java.util.Scanner;

public class Demo02Scanner_Practise {
    public static void main(String[] args) {
        //创建对象
        Scanner sc = new Scanner(System.in);
        //录入int型整数
        int data1 = sc.nextInt();
        System.out.println("data1 = " + data1);

        //录入String字符串
        String data2 = sc.next();
        System.out.println("data2 = " + data2);
    }
}

案例1

从键盘输入三位老人的年纪，并编写程序判断最大年龄是多大

package Better;

import java.util.Scanner;

public class Demo02Scanner_Practise {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int old1 = sc.nextInt();
        int old2 = sc.nextInt();
        int old3 = sc.nextInt();
        int tmp = old1>old2?old1:old2;
        int max = tmp>old3?tmp:old3;
        System.out.println("max = " + max);
    }
}

2.next和nextline的区别

变量名.next()：录入字符串 -> 遇到空格和回车就结束录入了

变量名.nextLine()：录入字符串 -> 遇到回车就结束录入了

import java.util.Scanner;

public class Demo03Scanner_differences {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String data1=sc.next();
        System.out.println("data1 = " + data1);
        String data2=sc.nextLine();
        System.out.println("data2 = " + data2);
    }
}

import java.util.Scanner;

public class Demo03Scanner_differences {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
//        String data1=sc.next();
//        System.out.println("data1 = " + data1);
        String data2=sc.nextLine();
        System.out.println("data2 = " + data2);
    }
}

3.注意

当用Scanner输入语句时，记住Scanner输入的类型，在输入时只能输入对应类型，类型应相匹配

二、Random_随机数

1.概述：Java自带的一个类

2.作用：可以在指定范围内随机一个参数

3.位置：java.util

4.使用：

①导包：import java.util.Random

②创建对象：

Random 变量名 = new Random()

③调用方法，生成随机数：

变量名.nextInt() -> 在int的取值范围内随机一个整数

import java.util.Random;

public class Demo04Random {
    public static void main(String[] args) {
        //创建对象
        Random rd = new Random();
        int data = rd.nextInt();
        System.out.println("data = " + data);
    }
}

在指定范围内随机一个数：

nextInt(int bound) -> 在 0~(bound - 1)

①nextInt(10) -> 0 ~ 9

②在1~10之间随机一个数：nextInt(10) + 1 -> (0 ~ 9) + 1 -> 1 ~ 10

③在1~100之间随机一个数：nextInt(100) + 1 -> (0 ~ 99) + 1 -> 1 ~100

④在100~999之间随机一个数：nextInt(900) + 100 -> (0 ~ 899) + 100 -> 100 ~ 999

案例1：

在1~100之间随机一个数

import java.util.Random;

public class Demo04Random {
    public static void main(String[] args) {
        //创建对象
        Random rd = new Random();
        //1~100之间的随机数
        int data = rd.nextInt(100+1);
        System.out.println("data = " + data);
    }
}

案例2：

在100~999之间随机一个数

public class Demo04Random {
    public static void main(String[] args) {
        //创建对象
        Random rd = new Random();
        //1~100之间的随机数
        int data = rd.nextInt(100+1);
        System.out.println("data = " + data);
        //100~999之间随机一个数
        int data1 = rd.nextInt(900)+100;
        System.out.println("data1 = " + data1);
    }
}

三、switch（选择语句）

1.switch基本使用

①格式：

switch(变量){

case 常量值1:

执行语句1;

break;

case 常量值2:

执行语句2;

break;

case 常量值3:

执行语句3;

break;

……

default:

执行语句n；

break;

}

②执行流程：

用变量接收的值和下面常量值进行匹配，匹配上哪个case就执行哪个case对应的执行语句，如果以上所有case都没有匹配上，就走default对应的执行语句n

③break关键字：代表的是结束switch语句

④注意：switch能匹配什么类型的数据：

byte short int char 枚举类型 String类型不能匹配浮点型数据

案例

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请您输入一个1~4之间的整数");
        int data = sc.nextInt();
        switch (data){
            case 1:
                System.out.println("鹅鹅鹅");
                break;
            case 2:
                System.out.println("\"曲项向天歌\" = " + "曲项向天歌");
                break;
            case 3:
                System.out.println("\"白毛浮绿水\" = " + "白毛浮绿水");
                break;
            case 4:
                System.out.println("\"红掌拨清波\" = " + "红掌拨清波");
                break;
            default:
                System.out.println("请您输入1~4范围内的数字");
                break;
        }
    }
}

2.case的穿透性

①如果没有break，就会出现case的穿透性，程序就会一直往下穿透执行，直到遇到了break或者switch代码执行完毕了，就停止了

②可以利用case的穿透性对代码进行优化，使代码简洁易懂

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请您输入一个1~4之间的整数");
        int data = sc.nextInt();
        switch (data){
            case 1:
                System.out.println(" 鹅鹅鹅");
                //break;
            case 2:
                System.out.println(" 曲项向天歌");
                //break;
            case 3:
                System.out.println(" 白毛浮绿水");
                //break;
            case 4:
                System.out.println(" 红掌拨清波");
                //break;
            default:
                System.out.println("请您输入1~4范围内的数字");
                break;
        }
    }

四、分支语句

1.if的第一种格式

①格式：

if(boolean表达式){

执行语句；

}

②执行流程：

先走if后面的boolean表达式，如果是true，就走if后面大括号中的执行语句，否则就不走

③注意：

if后面跟的是boolean表达式，只要是结果为boolean型的，都可以放在小括号中，哪怕直接写一个true或false

案例

判断两个整数是否相等

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请您输入两个数字：");
        int num1 = sc.nextInt();
        int num2 = sc.nextInt();
        if(num1 == num2){
            System.out.println("两个整数相等");
        }
    }

2.if的第二种格式

1.格式：

if(boolean表达式){

执行语句1；

}else{

执行语句2；

}

2.执行流程：

①先走if后面的boolean表达式，如果是true，就走if后面的执行语句1

②否则就走else后面的执行语句2

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请您输入两个数字：");
        int num1 = sc.nextInt();
        int num2 = sc.nextInt();
        if(num1 == num2){
            System.out.println("两个整数相等");
        }
        else{
            System.out.println("两个整数不相等");
        }
    }

案例1

任意给出一个整数，请用程序实现判断这个数是奇数还是偶数

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        if(num%2==1){
            System.out.println(num + "是奇数");
        }else{
            System.out.println(num+"是偶数");
        }
    }

案例2

利用if else语句，求出两个数中的较大值

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请您输入要比较的两个数");
        System.out.println("请您输入第一个数");
        int num1 = sc.nextInt();
        System.out.println("请您输入第二个数");
        int num2 = sc.nextInt();
        if(num1>num2){
            System.out.println("最大数是"+num1);
        }else{
            System.out.println("最大数是"+num2);
        }
    }

案例3

案例：从键盘输入年份，请输出该年的2月份的总天数，闰年29天，平年28天

闰年：①能被4整除，但不能被100整除 year%4==0 && year%100!=0

②或者能直接被400整除 year%400==0

     public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个年份");
        int year = sc.nextInt();
        if((year%4==0) && (year%100!=0)||year%400==0){
            System.out.println("该年是闰年，二月有29天");
        }else{
            System.out.println("该年是平年，二月有28天");
        }
    }

注意：若是boolean类型，则必定可以放入if表达式中

3.if的第三种格式

1.格式：

if(boolean表达式){

执行语句1

}else if(boolean表达式){

执行语句2

}else if(boolean表达式){

执行语句3

}……else{

执行语句n

}

2.执行流程：

从if开始往下挨个判断，哪个if判断结果为true，就走哪个if对应的执行语句，如果以上所有的判断都是false，就走else对应的执行语句n

3.使用场景：2种情况以上的判断

案例1

输入要比较的两个数，判断两个数的大小关系

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请您输入要比较的两个数");
        System.out.println("请您输入第一个数");
        int num1 = sc.nextInt();
        System.out.println("请您输入第二个数");
        int num2 = sc.nextInt();
        if(num1 > num2){
            System.out.println(num1+">"+num2);
        } else if (num1 == num2) {
            System.out.println(num1+"="+num2);
        } else{
            System.out.println(num1+"<"+num2);
        }
    }

注意：最后一种情况，不一定要用else，但是必须保证所有的情况都有

案例2

键盘输入一个星期数（1~7），输出对应的星期一、星期二、……星期日

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请您输入星期数目1~7");
        int week = sc.nextInt();
        if(week == 1){
            System.out.println("星期一");
        } else if (week == 2) {
            System.out.println("星期二");
        } else if (week == 3) {
            System.out.println("星期三");
        } else if (week == 4) {
            System.out.println("星期四");
        } else if (week == 5) {
            System.out.println("星期五");
        } else if (week == 6) {
            System.out.println("星期六");
        } else if (week == 7) {
            System.out.println("星期日");
        } else {
            System.out.println("您输入错误");
        }
    }

案例3

根据最新的年龄阶段划分标准：

0~6岁为婴幼儿

7~12岁为少儿

13~17岁为青少年

18~45岁为青年

46~69岁为中年

69岁以上为老年

请键盘录入一个年龄，判断属于什么年龄段

    public static void main(String[] args) {
        System.out.println("请您输入一个年龄");
        Scanner sc = new Scanner(System.in);
        int age = sc.nextInt();
        if(age>=0 && age<=6){
            System.out.println(age+"岁属于婴幼儿");
        }else if(age>=7 && age<=12){
            System.out.println(age+"岁属于少儿");
        }else if(age>=13 && age<=17){
            System.out.println(age+"岁属于青少年");
        }else if(age>=18 && age<=45){
            System.out.println(age+"岁属于青年");
        }else if(age>=46 && age<=69) {
            System.out.println(age+"岁属于中年");
        }else if (age>=70) {
            System.out.println(age+"岁属于老年");
        }else{
            System.out.println("输入错误");
        }
    }

4.switch和if的区别：

1.switch：会直接跳到相匹配的case

2.if：从上到下挨个判断 -> 实际开发主要使用if判断灵活

五、循环语句

当我们发现一件事情或者一段代码在反复执行，我们就可以考虑使用循环语句了

1.for循环的使用

1.格式：

for（初始化变量；比较；步进表达式）

循环语句 -> 哪段代码循环执行，就将哪段代码放在此处

}

2.执行流程：

①先走初始化变量

②比较，如果是true，走循环语句，走步进表达式（初始化的变量的值进行变化）

③再比较，如果还是true，继续走循环语句，走步进表达式

④再比较，直到比较为false，循环就结束了

public static void main(String[] args) {
    for (int i = 0; i < 3; i++) {
        System.out.println("一切都会好的，我一直相信");
    }
}

快捷键：次数.fori

5.fori

public static void main(String[] args) {
    for (int i = 0; i < 3; i++) {
        System.out.println("一切都会好的，我一直相信");
    }
        for (int j = 0; j < 5; j++) {
            System.out.println("万事胜意");
    }
}

案例1

for循环：求1-3之间的数据和，并把求和结果输出到控制台上

1+2+3

步骤：

①定义一个变量，来接收两个数的和，sum

②利用for循环将1~3表示出来

③再循环的过程中，两两相加，将结果赋值给sum

④输出sum

    public static void main(String[] args) {
        // ①定义一个变量，来接收两个数的和，sum
        int sum = 0;
        // ②利用for循环将1~3表示出来
        for (int i = 1; i <= 3; i++) {
            // ③再循环的过程中，两两相加，将结果赋值给sum
            sum+=i;
            i=i++;
        }
        // ④输出sum
        System.out.println(sum);
    }

案例2

for循环：求出1~100之间的偶数和

步骤：

①定义一个变量sum，接收两个偶数的和

②利用for循环将1~100表示出来

③判断，如果是偶数则把值加给sum

④输出sum

public static void main(String[] args) {

    //   ①定义一个变量sum，接收两个偶数的和
    int sum =0;
    //   ②利用for循环将1~100表示出来
    for (int i = 1; i <= 100; i++) {
        //   ③判断，如果是偶数则把值加给sum
        if(i%2==0){
            sum+=i;
        }
    }
    //   ④输出sum
    System.out.println(sum);
}

改进代码：

    public static void main(String[] args) {
        int sum = 0;
        for (int i = 0; i <= 100; i = i + 2) {
            sum += i;
        }
        System.out.println("一百以内偶数和为" + sum);
    }

案例3

统计一下1~100之间的偶数个数

步骤：

①定义一个变量count，用来计数

②利用for循环将1~100表示出来

③判断，如果是偶数，count++

④输出count

public static void main(String[] args) {
    // ①定义一个变量count，用来计数
    int count = 0;
    // ②利用for循环将1~100表示出来
     for (int i = 1; i <= 100; i++) {
        // ③判断，如果是偶数，count++
        if(i%2==0){
            count++;
        }
    }
    // ④输出count
    System.out.println("1~100间偶数个数为："+count);
}

2.while循环

1.格式：

初始化变量：

while(比较){

循环语句;

步进表达式

}

2.执行流程：

①初始化变量

②比较，如果是true，就走循环语句，走步进表达式

③再比较，如果还是true，继续走循环语句，继续走步进表达式

④再比较，直到比较为false，循环结束

public static void main(String[] args) {
    int i = 0;
    while(i<5){
        System.out.println("万事胜意");
        i++;
    }
}

案例1

while循环：求1-3之间的数据和，并把求和结果输出到控制台上

1+2+3

步骤：

①定义一个变量，来接收两个数的和，sum

②利用while循环将1~3表示出来

③再循环的过程中，两两相加，将结果赋值给sum

④输出sum

public static void main(String[] args) {
    // 定义一个变量，来接收两个数的和，sum
    int sum = 0;
    // ②利用while循环将1~3表示出来
    int i = 1;
    while(i<4){
        // ③再循环的过程中，两两相加，将结果赋值给sum
        sum+=i;
        i++;
        }
     // ④输出sum
    System.out.println(sum);
    }

案例2

while循环：求出1~100之间的偶数和

步骤：

①定义一个变量sum，接收两个偶数的和

②利用while循环将1~100表示出来

③判断，如果是偶数则把值加给sum

④输出sum

    public static void main(String[] args) {
        // ①定义一个变量sum，接收两个偶数的和
        int sum = 0;
        // ②利用while循环将1~100表示出来\
        int i = 1;
        while(i<=100) {
            // ③判断，如果是偶数则把值加给sum
            if(i%2==0){
                sum+=i;
            }
            i++;
        }
        // ④输出sum
        System.out.println(sum);
    }

案例3

统计一下1~100之间的偶数个数

步骤：

①定义一个变量count，用来计数

②利用while循环将1~100表示出来

③判断，如果是偶数，count++

④输出count

 public static void main(String[] args) {
        // ①定义一个变量count，用来计数
        int count = 0;
        // ②利用while循环将1~100表示出来
        int i = 1;
        while(i<=100) {
            // ③判断，如果是偶数，count++
            if(i%2==0){
                count++;
            }
            i++;
        }
        // ④输出count
        System.out.println(count);
    }

案例4*

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

步骤：

①定义一个变量表示山峰的高度：mountain

②定义一个变量表示纸的厚度：h

③定义一个变量表示折纸的次数：i

④利用while循环进行比较，如果h < mountain，就循环对折

public static void main(String[] args) {
    //① 定义一个变量表示山峰的高度：mountain
    int mountain = 8844430;
    //② 定义一个变量表示纸的厚度：h
    double h = 0.1;
    //③ 定义一个变量表示折纸的次数：i
    int i = 0;
    //④ 利用while循环进行比较，如果h < mountain，就循环对折
    while(h<mountain){
        h *= 2;
        i++;
    }
    System.out.println("折叠了"+i+"次");
}

3.do…while循环

1.格式：

初始化变量：

        do{

循环语句；

步进表达式

}while(比较)；

2.执行流程：

① 初始化变量

② 走循环语句

        ③ 走步进表达式

        ④ 判断，如果是true，继续循环，直到比较为false，循环结束

3.特点：

至少循环一次

public static void main(String[] args) {
    int i = 0;
    do{
        System.out.println("一切都会好的");
        i++;
    }while (i < 5);
}

4.循环控制语句 break&continue

1.break:

①在switch中代表结束switch语句

②在循环中代表循环结束

2.continue：

结束当前本次循环，直接进入下一次循环，直到条件为false为止

break：

    public static void main(String[] args) {
        for (int i = 1; i <=5 ; i++) {
            if(i==3){
                // 结束循环
                break;
                // 结束本次循环，进入下一次循环
                //continue
            }
            System.out.println("万事胜意");
        }
    }

continue：

    public static void main(String[] args) {
        for (int i = 1; i <=5 ; i++) {
            if(i==3){
                // 结束循环
                //break;
                // 结束本次循环，进入下一次循环
                continue;
            }
            System.out.println("万事胜意");
        }
    }

5.死循环

1.概述：

一直循环

2.什么条件下一直循环：

比较条件一直是true

for循环：

    public static void main(String[] args) {
        int count = 0;
        for (int i = 0; i < 3; ) {
            count++;
            System.out.println("一切都会好的"+count);
        }
    }

while循环：

public static void main(String[] args) {
        int count = 0;
//        for (int i = 0; i < 3; ) {
//            count++;
//            System.out.println("一切都会好的"+count);
//        }
        while(true){
            System.out.println(count);
            count++;
        }
    }

6.嵌套循环

1.概述：循环中还有循环

eg、时分秒

2.执行流程：

先执行外层循环，在进入内层循环，内层循环就一直循环，直到内层循环结束，外层循环进入下一次循环，直到外层循环结束了，整体结束

 public static void main(String[] args) {
    for (int shi = 0; shi < 24; shi++) {
        for (int fen = 0; fen < 60; fen++) {
            for (int miao = 0; miao < 60; miao++) {
                System.out.println(shi+"时"+fen+"分"+miao+"秒");
            }
        }
    }
}

练习1：打印矩形

public static void main(String[] args) {
    //外层循环控制行
    for (int i = 0; i < 5; i++) {
        //内层循环控制列
        for (int j = 0; j < 5; j++) {
            System.out.print("* ");
        }
        System.out.println();
    }
}

练习2：打印直角三角形

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

练习3* 猜数字小游戏

1.创建Scanner和Random对象

2.调用Random中的nextInt(100)+1在1~100之间随机一个数 rdNumber

3.调用Scanner中的nextInt()方法，键盘录入一个要猜的数 scNumber

4.如果scNumber > rdNumber，证明猜大了

5.如果scNumber < rdNumber，证明猜小了

6.如果scNumber = rdNumber，证明猜对了

public class Demo28GuessNumberGame {
    public static void main(String[] args) {
        //只允许七次之内猜出
        int i = 0;
        //1.创建Scanner和Random对象
        Scanner sc = new Scanner(System.in);
        Random rd = new Random();
        //2.调用Random中的nextInt(100)+1在1~100之间随机一个数 rdNumber
        int rdNumber = rd.nextInt(99) + 1;
        while (i < 7) {
            i++;
            //3.调用Scanner中的nextInt()方法，键盘录入一个要猜的数 scNumber
            System.out.println("请您输入您要猜的数字：");
            int scNumber = sc.nextInt();
            //4.如果scNumber > rdNumber，证明猜大了
            if (scNumber > rdNumber) {
                System.out.println("猜大了");
                System.out.println("这是第" + i + "次猜");
                continue;
            }
            //5.如果scNumber < rdNumber，证明猜小了
            else if (scNumber < rdNumber) {
                System.out.println("猜小了");
                System.out.println("这是第" + i + "次猜");
                continue;
            }
            //6.如果scNumber = rdNumber，证明猜对了
            else {
                System.out.println("猜对了");
                System.out.println("这是第" + i + "次猜");
                break;
            }
        }
    }
}