day04_数据输入（Scannery类）丶流程控制语句

引用类型的使用步骤

1：导包

使用import关键字导包，在类的所有代码之前导包，引入要使用的类型，java.lang包下的所有类无需导入。

格式：

• import 包名.类名;

2：创建对象

• 使用该类的构造方法，创建一个该类的对象。

格式：

• 数据类型 变量名 = new 数据类型(参数列表);

3：调用方法名/变量名

• 调用该类的成员方法，完成指定功能。格式： 变量名.方法名();
• 调用该类的成员变量，获取指定的值。格式：变量名.变量名称；

Scanner类

一个可以解析基本类型和字符串的简单文本扫描器。 例如，以下代码使用户能够从 System.in 中读取一个数：

查看类

• java.util.Scanner ：该类需要import导入后使用。导包的语句需要定义在类的上面。

查看构造方法

• public Scanner(InputStream source) : 构造一个新的 Scanner ，它生成的值是从指定的输入流扫描的。

查看成员方法

• nextInt(); 用来接收控制台录入的数字
• sc.next(); 用来接收控制台录入的字符串

代码示例

import java.util.Scanner;

public class DemoScanner {
    public static void main(String[] args) {
        // 创建对象
        Scanner sc = new Scanner(System.in);
        // 接收数据
        System.out.println("请输入第一个数据：");
        int a = sc.nextInt();
        System.out.println("请输入第二个数据：");
        int b = sc.nextInt();
        System.out.println("请输入第三个数据：");
        int c = sc.nextInt();
        // 如何获取三个数据的最大值
        int temp = (a > b ? a : b);
        int max = (temp > c ? temp : c);
        System.out.println("max:" + max);
    }
}

流程控制语句

流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组 合成能完成一定功能的小逻辑模块。其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即：

• 顺序结构：程序从上到下逐行地执行，中间没有任何判断和跳转。
• 分支结构：根据条件，选择性地执行某段代码，有if…else和switch-case两种分支语句。
• 循环结构：根据循环条件，重复性的执行某段代码。有while、do…while、for三种循环语句。

顺序结构

程序顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。

顺序结构执行流程图：

示例

/*
    顺序结构
*/
public class OrderDemo {
    public static void main(String[] args) {
        System.out.println("开始");
        
        System.out.println("语句A");
        System.out.println("语句B");
        System.out.println("语句C");
        
        System.out.println("结束");
    }
}

分支结构之if语句

if语句第一种格式： if

格式：

执行流程：

• ①首先计算关系表达式的值
• ②如果关系表达式的值为true就执行语句体
• ③如果关系表达式的值为false就不执行语句体
• ④继续执行后面的语句内容

 if语句流程图

 示例

/*
    if语句格式1

    格式：
        if (关系表达式) {
            语句体;    
        }
    
    执行流程：
        1:首先计算关系表达式的值
        2:如果关系表达式的值为true就执行语句体
        3:如果关系表达式的值为false就不执行语句体
        4:继续执行后面的语句内容
*/
public class Demo {
    public static void main(String[] args) {

        //定义两个变量
        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");//a等于c
        }

        System.out.println("结束");//结束
    }
}

if语句第二种格式： if...else

格式：

执行流程：

• ①首先计算关系表达式的值
• ②如果关系表达式的值为true就执行语句体1
• ③如果关系表达式的值为false就执行语句体2
• ④继续执行后面的语句内容

 if....else语句的执行流程图

 示例

import java.util.Scanner;

/*
    if语句格式2

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

    执行流程：
        1:首先计算关系表达式的值
        2:如果关系表达式的值为true就执行语句体1
        3:如果关系表达式的值为false就执行语句体2
        4:继续执行后面的语句内容

    需求：
        任意给出一个整数，请用程序实现判断该整数是奇数还是偶数，并在控制台输出该整数是奇数还是偶数。
*/
public class Demo {
    public static void main(String[] args) {
        //为了体现任意给出一个整数，采用键盘录入一个数据。(导包，创建对象，接收数据)
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数：");
        //获取从外界输入的数字
        int number = sc.nextInt();
        /*
        判断整数是偶数还是奇数要分两种情况进行判断，使用if..else结构
        判断是否偶数需要使用取余运算符实现该功能 number % 2 == 0    
        根据判定情况，在控制台输出对应的内容
         */
        if (number % 2 == 0) {
            System.out.println(number + "是偶数");
        } else {
            System.out.println(number + "是奇数");
        }

    }
}

if语句第三种格式： if...else if ...else

格式：

执行流程：

• ①首先计算关系表达式1的值
• ②如果值为true就执行语句体1；如果值为false就计算关系表达式2的值
• ③如果值为true就执行语句体2；如果值为false就计算关系表达式3的值
• ④…
• ⑤如果没有任何关系表达式为true，就执行语句体n+1。 

if..else if...else执行流程图

示例：

/*
    if语句格式3

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

    执行流程：
        1:首先计算关系表达式1的值
        2:如果值为true就执行语句体1；如果值为false就计算关系表达式2的值
        3:如果值为true就执行语句体2；如果值为false就计算关系表达式3的值
        4:…
        5:如果没有任何关系表达式为true，就执行语句体n+1。

需求：小明快要期末考试了，小明爸爸对他说，会根据他不同的考试成绩，送他不同的礼物，假如你可以控制小明的得分，请用程序实现小明到底该获得什么样的礼物，并在控制台输出。

    奖励：
        95~100        山地自行车一辆
        90~94        游乐场玩一次
        80~89        变形金刚玩具一个
        80以下        胖揍一顿
*/
import java.util.Scanner;

public class Demo {
    public static void main(String[] args) {
        //小明的考试成绩未知，可以使用键盘录入的方式获取值
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入一个分数：");
        int score = sc.nextInt();

        /*
        由于奖励种类较多，属于多种判断，采用if...else...if格式实现
        为每种判断设置对应的条件
        为每种判断设置对应的奖励
        */
        //数据测试：正确数据，边界数据，错误数据
        if(score>100 || score<0) {
            System.out.println("你输入的分数有误");
        } else if(score>=95 && score<=100) {
            System.out.println("山地自行车一辆");
        } else if(score>=90 && score<=94) {
            System.out.println("游乐场玩一次");
        } else if(score>=80 && score<=89) {
            System.out.println("变形金刚玩具一个");
        } else {
            System.out.println("胖揍一顿");
        }
    }
}

小结选择结构if语句

• 条件表达式必须是布尔表达式（关系表达式或逻辑表达式）、布尔变量
• 语句块只有一条执行语句时，一对{}可以省略，但建议保留
• if-else语句结构，根据需要可以嵌套使用
• 当if-else结构是“多选一”时，最后的else是可选的，根据需要可以省略
• 当多个条件是“互斥”关系时，条件判断语句及执行语句间顺序无所谓
• 当多个条件是“包含”关系时，“小上大下 / 子上父
• 在某些简单的应用中，if语句是可以和三元运算符互换使用的。 三元运算符的执行效率比if语句要高，if语句的适用范围比三元运算符要多的多。

分值结构之switch语句

格式：

执行流程

• 首先计算出表达式的值
• 其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结 束。
• 最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

switch执行流程示意图

示例代码

import java.util.Scanner;

/*
    switch语句

    格式：
        switch(表达式) {
            case 值1：
            语句体1;
            break;
            case 值2：
            语句体2;
            break;
            …
            default：
            语句体n+1;
            [break;]
        }

    格式说明：
        表达式：取值为byte、short、int、char，JDK5以后可以是枚举，JDK7以后可以是String。
        case：后面跟的是要和表达式进行比较的值。
        break：表示中断，结束的意思，用来结束switch语句。
        default：表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。

    执行流程：
        首先计算表达式的值。
        依次和case后面的值进行比较，如果有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
        如果所有的case后面的值和表达式的值都不匹配，就会执行default里面的语句体，然后程序结束掉。

需求：
一年有12个月，分属于春夏秋冬4个季节，键盘录入一个月份，请用程序实现判断该月份属于哪个季节，并输出。
                春：3、4、5
                夏：6、7、8
                秋：9、10、11
                冬：1、2、12
*/
public class Demo {
    public static void main(String[] args) {
        //键盘录入月份数据，使用变量接收
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个月份：");
        int month = sc.nextInt();
        //case穿透
        switch (month) {
            case 1:
            case 2:
            case 12:
                System.out.println("冬季");
                break;
            case 3:
            case 4:
            case 5:
                System.out.println("春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏季");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("秋季");
                break;
            default:
                System.out.println("你输入的月份有误");
        }
    }
}

switch语句有关规则

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

if和switch语句很像，具体什么场景下，应用哪个语句呢？

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

循环语句

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

循环语句之一：for循环

格式：

执行流程：

执行顺序：①②③④>②③④>②③④…②不满足为止。

• ①负责完成循环变量初始化。初始化部分(init_statement)：在循环开始最初执行，而且只做唯一一次。初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔
• ②负责判断是否满足循环条件，不满足则跳出循环。循环条件部分(test_exp) ：如果成立，则循环继续；如果不成立，则循环退出。循环条件部分必须是boolean类型表达式，当值为false时，退出循环
• ③具体执行的语句。循环体部分(body_statement)：重复要做的事情内容，若干行语句。
• ④循环后，循环条件所涉及变量的变化情况。迭代部分(alter_statement)：每次循环之后都要进行的扫尾工作，每次循环结束之后都要执行一次。可以有多个变量更新，用逗号分隔。

for循环代码执行示意图

 示例

/*
    for语句

    格式：
        for(初始化语句;条件判断语句;条件控制语句) {
            循环体语句;
        }

    执行流程：
        1:执行初始化语句
        2:执行条件判断语句，看其结果是true还是false
            如果是false，循环结束
            如果是true，继续执行
        3:执行循环体语句
        4:执行条件控制语句
        5:回到2继续
 */
/*
    统计
    
    需求：
        统计"水仙花数"一共有多少个，并在控制台输出个数
*/
public class Demo {
    public static void main(String[] args) {
        //定义变量count，用于保存“水仙花数”的数量，初始值为0
        int count = 0;

        //输出所有的水仙花数必然要使用到循环，遍历所有的三位数，三位数从100开始，到999结束
        for (int i = 100; i < 1000; i++) {
            //在计算之前获取三位数中每个位上的值
            int ge = i % 10;
            int shi = i / 10 % 10;
            int bai = i / 10 / 10 % 10;

            //在判定水仙花数的过程中，满足条件不再输出，更改为修改count的值，使count+1
            if (ge * ge * ge + shi * shi * shi + bai * bai * bai == i) {
                count++;
            }
        }

        //打印输出最终结果
        System.out.println("水仙花共有：" + count + "个");
    }
}

循环语句之二：while 循环

格式：

执行流程

执行顺序：①②③④>②③④>②③④…②不满足为止。

• ①负责完成循环变量初始化。
• ②负责判断是否满足循环条件，不满足则跳出循环。
• ③具体执行的语句。
• ④循环后，循环变量的变化情况。

while循环代码执行示意图

示例

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

/*
    while语句

    基本格式：
        while(条件判断语句) {
            循环体语句;
        }

    完整格式：
        初始化语句;
        while(条件判断语句) {
            循环体语句;
            条件控制语句;
        }

    执行流程：
        1:执行初始化语句
        2:执行条件判断语句，看其结果是true还是false
            如果是false，循环结束
            如果是true，继续执行
        3:执行循环体语句
        4:执行条件控制语句
        5:回到2继续
 */
public class Demo {
    public static void main(String[] args) {
        //定义一个计数器，初始值为0
        int count = 0;

        //定义纸张厚度
        double paper = 0.1;

        //定义珠穆朗玛峰的高度
        int zf = 8844430;

        //因为要反复折叠，所以要使用循环，但是不知道折叠多少次，这种情况下更适合使用while循环
        //折叠的过程中当纸张厚度大于珠峰就停止了，因此继续执行的要求是纸张厚度小于珠峰高度
        while (paper <= zf) {
            //循环的执行过程中每次纸张折叠，纸张的厚度要加倍
            paper *= 2;

            //在循环中执行累加，对应折叠了多少次
            count++;
        }

        //打印计数器的值
        System.out.println("需要折叠：" + count + "次");//需要折叠：27次
    }
}

 循环语句之三：do...while

格式：

执行流程

执行顺序：①③④>②③④>②③④…②不满足为止。

• ①负责完成循环变量初始化。
• ②负责判断是否满足循环条件，不满足则跳出循环。
• ③具体执行的语句
• ④循环后，循环变量的变化情况

​​​​​​​do...while 代码执行示意图

 示例：

/*
    do...while语句

    基本格式：
        do {
            循环体语句;
        }while(条件判断语句);
        
    完整格式：
        初始化语句;
        do {
            循环体语句;
            条件控制语句;
        }while(条件判断语句);

    执行流程：        
        1:执行初始化语句
        2:执行循环体语句
        3:执行条件控制语句
        4:执行条件判断语句，看其结果是true还是false
            如果是false，循环结束
            如果是true，继续执行
        5:回到2继续
 */
public class DoWhileDemo {
    public static void main(String[] args) {
        //需求：在控制台输出5次"HelloWorld"
        //for循环实现
        for(int i=1; i<=5; i++) {
            System.out.println("HelloWorld");
        }
        System.out.println("--------");
        
        //do...while循环实现
        int j = 1;
        do {
            System.out.println("HelloWorld");
            j++;
        }while(j<=5);
        
    }
}

三种循环的区别

• for循环和while循环先判断条件是否成立，然后决定是否执行循环体（先判断后执行）
• do...while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后判断）

for循环和while的区别

• 条件控制语句所控制的自增变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了
• 条件控制语句所控制的自增变量，对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用
• 在已知循环次数的时候使用推荐使用for，循环次数未知的时推荐使用while。

死循环

死循环：也就是循环中的条件永远为true，死循环的是永不结束的循环。最简单“无限” 循环格式：while(true) , for(;;),无限循环存在的原因是并不知道循环多少次，需要根据循环体内部某些条件，来控制循环的结束。在后期的开发中，会出现使用死循环的场景，例如：我们需要读取用户输入的输入，但是用户输入多少数据我们并不清楚，也只能使用死循环，当用户不想输入数据了，就可以结束循环了，如何去结束一个死循环呢，就需要使用到跳出语句了。

死循环（无限循环）的三种格式

• for(;;){}
• while(true){}
• do {} while(true);

示例

/*
永远停不下来的循环，叫做死循环。最常用的死循环的标准格式：
while (true) {
    循环体
}
*/
public class DemoDeadLoop {
    public static void main(String[] args) {
        while (true) {
            System.out.println("I Love Java!");
        }
        
        // System.out.println("Hello"); 错误，永远执行不到的代码，不能编写
    }
}

程序流程控制关键字

关键字：break

• 用在switch语句当中，一旦执行，整个switch语句立刻结束。
• 用在循环语句当中，一旦执行，整个循环语句立刻结束。打断循环。

示例：

public class DemoBreak {
    public static void main(String args[]) {
        for (int i = 0; i < 10; i++) {
            if (i == 3)
                //执行break循环结束
                break;
            System.out.println(" i =" + i);
        }
        System.out.println("Game Over!");
    }
}

关键字：continue 

• continue只能使用在循环结构中
• continue语句用于跳过其所在循环语句块的一次执行，继续下一次循环

示例：

/*
另一种循环控制语句是continue关键字。
一旦执行，立刻跳过当前次循环剩余内容，马上开始下一次循环。
*/
public class DemoContinue {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            if (i == 4) { // 如果当前是第4层
                continue; // 那么跳过当前次循环，马上开始下一次（第5层）
            }
            System.out.println(i + "层到了。");
        }
    }
}

特殊流程控制语句说明

• break只能用于switch语句和循环语句中。
• continue 只能用于循环语句中。
• 二者功能类似，但continue是终止本次循环，break是终止本层循环。
• break、continue之后不能有其他的语句，因为程序永远不会执行其后的语句。
• 标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。

循环嵌套

所谓嵌套循环，是指一个循环的循环体是另一个循环。将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while均可以作为外层循环或内层循环。 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开 始下一次的循环。请反复理解这句话：整个内循环，就是外循环的一个循环体，内部循环体没有执行完毕，外循环是不会继续向下执行的。结论：外循环执行一次，内循环执行一圈 

格式：

   

嵌套循环执行流程：

• 执行顺序：①②③④⑤⑥>④⑤⑥>⑦②③④⑤⑥>④⑤⑥
• 外循环一次，内循环多次。

​​​​​​​代码演示

/*
    循环嵌套：
        循环语句中包含循环语句
    
    需求：
        在控制台输出一天的小时和分钟
        
        分钟和小时的范围：
            分钟：0 <= minute < 60
            小时：0 <= hour < 24
*/
public class ForForDemo {
    public static void main(String[] args) {

        //外循环控制小时的范围，内循环控制分钟的范围
        for (int hour = 0; hour < 24; hour++) {
            for (int minute = 0; minute < 60; minute++) {
                System.out.println(hour + "时" + minute + "分");
            }
            System.out.println("");
        }
    }
}