一、晨考

1、请写出 8 种基本数据类型及其占的字节宽度

数据类型	字节宽度（单位字节）
byte	1
short	2
int	4
long	8
float	4
double	8
char	2
boolean	1

2、请写出 byte 类型的存储范围

txt

-128 ~ 127
-2的7次方 ~ 2的7次方-1

3、请解释 & 和 && 的区别

txt

&：普通的逻辑与或按位与，不会发生短路
&&：短路与，当左边的值是false时，右边就不看不执行

4、请解释 = 和 == 的区别

txt

=：赋值
==：判断2个值是否相等

5、请写出以下代码的运行结果

java

int i = 1;
i = i++; //（1）先取i的值1（2）i紧接着自增1 i=2 (3)把之前取出来的i的值重新赋值给i   i=1
System.out.println(i);//1

int j = 1;
i *= i+j; //等价于 i = i * (i+j)
System.out.println(i);//2

二、复习

1、计算机存储数据的单位

bit：比特，1 位，要么是 0 要么是 1
byte：字节，1 个字节 = 8 位
- 有符号（有正有负）: -128 ~ 127
- 无符号（不考虑负数）：0 ~ 255
2 个字节：
- 有符号（short）：-32768 ~ 32767
- 无符号（char）：0 ~ 65535

2、符号位、原码、反码、补码

二进制的最高位是符号位
对于正数来说（二进制位最高位是 0），原码、反码、补码都一样
对于负数来说（二进制为最高位是 1），原码、反码、补码是不同的
- 计算器或计算机来说，看补码
- 人工进行权值相加法来说，看原码

3、基本数据类型转换

boolean 不参与
自动类型转换：小->大
- 赋值操作：把类型小的值赋值给类型大的变量
- 混合运算
- 特殊：byte，short，char 它们计算时会升级为 int
强制类型转换：
- (类型)值
- 赋值操作：把类型大的值赋值给类型小的变量，有风险（溢出截断或损失精度）
- 计算时强制提升某个值的类型

4、运算符

算术运算符：

txt

加：+（求和、拼接）    +有一边是字符串就是拼接
减：-
乘：*
除：/     整数/整数还是整数   整数/0报错   小数/0得到Infinity
模：%		结果的正负号看被除数  整数%0报错  小数%0得到NaN
自增：++
自减：--
	a++;  ++a;  单独成语句时没有区别，都是a自增1
	System.out.println(a++);
	System.out.println(++a);
	int i = 1;
	i = i++;
	i = ++i;
	当自增不是独立语句时：
		++在前，先自增后取值。用于输出或其他计算的值是自增之后的。
		++在后，先取值再自增。用于输出或其他计算的值是自增之前的。

比较运算符（计算结果都是 true 或 false）

txt

大于：>
小于：<
大于等于：>=
小于等于：<=
等于：==
不等于：!=

逻辑运算符

txt

逻辑与： &    只有两边都为true，结果才为true，其余都是false。当左边为false时，右边还得看。
逻辑或： |    只要一边为true，结果就为true，只有两边为false，结果才为false。当左边为true时，右边继续看。
逻辑异或：^    只有两边不同，结果才为true，两边相同，结果就为false
逻辑非： !     取反，  !true结果是false, !false结果是true
短路与： &&   只有两边都为true，结果才为true，其余都是false。当左边为false时，右边不看。
短路或： ||   只要一边为true，结果就为true，只有两边为false，结果才为false。当左边为true时，右边不看。

条件运算符

java

条件 ? 结果1 ： 结果2

位运算符

txt

左移： <<   左移几位，相当于乘以2的几次方。   可能出现正变负，负变正。
右移： >>   右移几位，相当于除以2的几次方。   不会出现正变负，负变正。
无符号右移： >>>
		正数>>>与正数>>相同
		负数一旦>>>就变为正数
按位与： &  两个位都是1，结果是1，其余都是0
按位或： |  两个位有一个是1，结果就是1，只有0 | 0 结果才为0.
按位异或：^ 两个位不同，一个是1一个是0，结果才为1，相同为0
按位取反：~  所有位包括符号位都取反。  正变负，负变正

赋值运算符

txt

单独的=
复合的
	+=,-=,*=,/=,%=,>>=,<<=,>>>=,&=,|=,^=

三、流程控制语句结构

流程的走向中涉及到 3 种情况：

顺序结构：按步骤依次执行
分支结构：根据条件判断走哪个分支
循环结构：某些步骤可能需要重复执行

Java 中有一些特定的结构来控制流程。

3.1 顺序结构

Java 中程序整体来说是按照顺序结构依次执行的。其中两个比较特殊的语句：输入和输出语句。当然赋值语句、计算语句，都是按顺序执行。

3.1.1 输出语句（掌握）

输出 xx 内容之后然后换行

java

System.out.println();
System.out.println(各种类型);

输出 xx 内容之后不换行

java

System.out.print();//错误，()不能空着
System.out.print(各种类型);

java

public class OutStatementTest1 {
    public static void main(String[] args) {
        //System.out.println()中支持哪些类型，可以通过快捷键 Ctrl + P查看
        System.out.println("hello world");
        System.out.println();
        System.out.println(1);
        System.out.println(1L);
        System.out.println(true);
        System.out.println(5.5F);
        System.out.println(5.5);
        System.out.println('a');

        byte b = 1;
        System.out.println(b);
    }
}

java

public class OutStatementTest2 {
    public static void main(String[] args) {
        System.out.print("hello world");
        System.out.print(1);
        System.out.print('1');
        System.out.print(true);
    }
}

3.1.2 输入语句（掌握）

输入语句是指当程序运行时，用户可以在控制台输入数据，这个数据可以被程序接收并使用。

java

import java.util.Scanner;//导包语句

public class InStatementTest1 {
    public static void main(String[] args) {
        /*
        Java中规定，使用java.lang包的核心类库，例如：String，System，Math等，不需要导包。
        但是如果使用其他包的核心类库，例如：Scanner等，需要加一句import语句，即导包，即告诉JVM，去哪个文件夹下找这个类。

        System.out：输出xx内容到控制台
        System.in：从控制台接收用户输入的数据

        Scanner input = new Scanner(System.in); 代码中只有1个地方我们可以修改，input
            input是一个标识符，或者它是一个变量名，或者它是一个对象名
            标识符的概念 > 变量名的概念 > 对象名的概念

            input的命名只要遵循标识符的命名规则和规范，建议见名知意，小驼峰命名法
         */
        Scanner input = new Scanner(System.in);

        /*
        当用户输入的数据的类型与接收数据的变量的类型不一致，
        就会发生java.util.InputMismatchException（输入不匹配异常）
         */

        System.out.print("请输入姓名：");
        String name = input.next();//从控制台扫描用户输入的下一个字符串

        System.out.print("请输入年龄：");
        int age = input.nextInt();

        System.out.print("请输入体重：");
        double weight = input.nextDouble();

        System.out.print("请输入性别：");
//        String sex = input.next();
        char sex = input.next().charAt(0);//先以字符串扫描，0代表然后从字符串中取第1个字符。

        System.out.print("请输入是否单身：");
        boolean isSingle = input.nextBoolean();

        System.out.println("name = " + name);
        System.out.println("age = " + age);
        System.out.println("weight = " + weight);
        System.out.println("sex = " + sex);
        System.out.println("isSingle = " + isSingle);

        input.close();
        //最后一句，不写，程序不会报错
        //但是通常我们会建议大家写这句话
        //因为键盘输入涉及到IO操作，IO操作涉及到硬件的操作，Java不能直接操作硬件，会调用一下C的代码，这个时候需要告诉JVM需要手动释放一些资源和内存。
        //涉及到IO操作，网络连接等都需要释放资源
    }
}

3.1.3 IDEA 安装通易灵码插件

3.1.4 输入的复杂情况（拓展）

1、一行输入多个值

一行输入多个值：用空格分割。适用于next()，nextInt()、nextDouble()、nextBoolean()等，不包括nextLine()

java

import java.util.Scanner;

public class InStatementTest2 {
    public static void main(String[] args) {
        //从键盘输入3个整数
        Scanner sc = new Scanner(System.in);

        System.out.print("请输入3个整数（整数之间用空格分割）：");
        int a = sc.nextInt();
        int b = sc.nextInt();
        int c = sc.nextInt();

        System.out.println("a = " + a);
        System.out.println("b = " + b);
        System.out.println("c = " + c);

        sc.close();
    }
}

2、一次读取一行

一次读取一行：使用nextLine()

java

import java.util.Scanner;

public class InStatementTest3 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        //姓名中可能包含空格
        System.out.print("请输入姓名：");
//        String name = sc.next();//名字中无法包含空格
        String name = sc.nextLine();//名字中可以包含空格

        System.out.println("name = " + name);
    }
}

3、当next()等与nextLine()混用容易有问题

java

import java.util.Scanner;

public class InStatementTest4 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

     /*   System.out.print("请输入编号：");
        int id = sc.nextInt();//5回车

        System.out.print("请输入姓名：");
        String name = sc.nextLine();//读取了5后面的回车换行*/

        System.out.print("请输入编号：");
        int id = sc.nextInt();//5回车
        sc.nextLine();//读取了5后面的回车换行，这里不需要接收，因为这个回车符对我们来说没有用

        System.out.print("请输入姓名：");
        String name = sc.nextLine();

        System.out.println("id = " + id);
        System.out.println("name = " + name);

        sc.close();
    }
}

3.1.5 IDEA 自动导包设置

3.2 分支结构之条件判断

关键词：if-else

3.2.1 单分支条件判断（掌握）

语法格式：

java

if(条件){
    语句;
}

执行的特点：条件成立就执行{}中的语句，不成立就不执行。

说明：当{}中的语句只有 1 个语句时，那么{}可以省略

java

import java.util.Scanner;

public class IfTest {
    public static void main(String[] args) {
        //需求：从键盘输入一个年份，如果年份是闰年，就给总天数加1天
        int totalOfYear = 365;

        Scanner sc = new Scanner(System.in);
        System.out.print("请输入年份：");
        int year = sc.nextInt();

        /*
        闰年的条件
        （1）可以被4整除且不能被100整除
        （2）能被400整除
         */
        if(year%4==0 && year%100!=0 || year%400==0){
            totalOfYear++;
        }
        System.out.println(year+"的总天数是" + totalOfYear);

        sc.close();
    }
}

多个单分支结构各自是独立的

java

import java.util.Scanner;

public class IfTest2 {
    public static void main(String[] args) {
        //需求：从键盘输入1个整数，如果它是3的倍数，就输出three，如果它是5的倍数，就输出five，如果它是7的倍数，就输出seven
        Scanner sc = new Scanner(System.in);

        System.out.print("请输入一个整数：");
        int number = sc.nextInt();

        if(number % 3 == 0) {
            System.out.println("three");
        }
        if(number % 5 == 0) {
            System.out.println("five");
        }
        if(number % 7 == 0) {
            System.out.println("seven");
        }
        /*
        上面这么写代表3个if是独立的。3个条件都要依次判断。
         */

        sc.close();
    }
}

3.2.2 双分支条件判断（掌握）

语法格式：

java

if(条件){
    语句1;
}else{
    语句2;
}

执行的特点：条件成立就执行 if{}中的语句 1，不成立就执行 else{}中的语句 2。

说明：当{}中的语句只有 1 个语句时，那么{}可以省略。如果{}中有多个语句，{}千万不能省略。

java

import java.util.Scanner;

public class IfElseTest {
    public static void main(String[] args) {
        //需求：从键盘输入一个整数，输出它是奇数还是偶数
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入一个整数：");
        int num = sc.nextInt();

       /* if(num %2 == 0) {
            System.out.println(num + "是偶数");
            System.out.println(num + "是双数");
        }else {
            System.out.println(num + "是奇数");
        }*/

        System.out.println(num%2==0 ? "偶数" : "奇数");

        sc.close();
    }
}

3.2.3 多分支条件判断（掌握）

语法格式：

java

if(条件1){
    语句1;
}else if(条件2){
    语句2;
}else if(条件3){
    语句3;
}else{
    语句4;
}

说明：当{}中的语句只有 1 个语句时，那么{}可以省略。如果{}中有多个语句，{}千万不能省略。

执行特点：

先判断条件 1，如果条件 1 成立了，就执行语句 1，剩下的条件和语句都不看不执行了。
如果条件 1 不成立，继续看条件 2，如果条件 2 成立了，就执行语句 2，剩下的条件和语句都不看不执行了。
以此类推
如果所有的 if 都不成立，就执行最后的 else

java

import java.util.Scanner;

public class IfElseIfTest {
    public static void main(String[] args) {
        /*
        从键盘输入一个成绩。
        如果成绩超过[0,100]范围，提示成绩输入错误
        如果成绩是100，提示满分
        如果成绩是[85,99]，提示优秀
        如果成绩是[70,84]，提示良好
        如果成绩是[60,69]，提示及格
        如果成绩是[0,59]，提示不及格
         */
        Scanner sc = new Scanner(System.in);

        System.out.print("请输入成绩：");
        int score = sc.nextInt();

        //1个多分支
        if(score<0  || score>100){
            System.out.println("成绩输入有误，成绩范围是[0,100]");
        }else if(score == 100){
            System.out.println("满分");
        }else if(score>=85){//当程序判断到这里时，说明成绩在[0,99]之间
            System.out.println("优秀");
        }else if(score>=70){
            System.out.println("良好");
        }else if(score>=60){
            System.out.println("及格");
        }else{
            System.out.println("不及格");
        }

        sc.close();
    }
}

3.2.4 条件判断的嵌套使用（掌握）

java

import java.util.Scanner;

public class IfNestTest {
    public static void main(String[] args) {
        //需求：请输入一个年份，判断它是平年还闰年。要求年份必须是正数。
        Scanner sc = new Scanner(System.in);

        System.out.print("请输入一个年份值：");
        int year = sc.nextInt();

        if(year>0){
            //当if(year>0)成立的情况下，才继续判断里面的if-else
            if(year%4==0 && year%100!=0 || year%400==0){
                System.out.println(year +"是闰年");
            }else{
                System.out.println(year +"是平年");
            }
        }else{
            System.out.println("年份必须是正数！");
        }

    }
}

3.2.5 练习题

1、彩票

java

import java.util.Scanner;

public class IfElseExercise3 {
    public static void main(String[] args) {
        /*
        3、假设你想开发一个玩彩票的游戏，程序随机地产生一个两位数的彩票，
        提示用户输入一个两位数，然后按照下面的规则判定用户是否能赢。
        1)如果用户输入的数匹配彩票的实际顺序，奖金10 000美元。
        2)如果用户输入的所有数字匹配彩票的所有数字，但顺序不一致，奖金 3 000美元。
        3)如果用户输入的一个数字仅满足顺序情况下匹配彩票的一个数字，奖金1 000美元。
        4)如果用户输入的一个数字仅满足非顺序情况下匹配彩票的一个数字，奖金500美元。
        5)如果用户输入的数字没有匹配任何一个数字，则彩票作废。
        提示：使用Math.random() 产生随机数

        Math.random()得到[0,1)范围的小数
        Math.random()*90  得到[0, 90)的小数
        Math.random()*90+10  得到[10, 100)的小数
        (int)(Math.random()*90+10) 得到[10, 100)的整数
         */

        int randNum = (int) (Math.random() * 90 + 10);

        Scanner input = new Scanner(System.in);

        System.out.print("请输入一个两位数[10,100)：");
        int inputNum = input.nextInt();

        if(inputNum == randNum){
            System.out.println("奖金10000美元");
        }else if(inputNum/10 == randNum%10 && inputNum%10==randNum/10){
            System.out.println("奖金3000美元");
        }else if(inputNum/10 == randNum/10 || inputNum%10 == randNum%10){
            System.out.println("奖金1000美元");
        }else if(inputNum/10 == randNum%10 || inputNum%10==randNum/10){
            System.out.println("奖金500美元");
        }else{
            System.out.println("谢谢惠顾！");
        }

        System.out.println("本期中奖号码：" + randNum);

        input.close();
    }
}

2、3 个数排序

java

import java.util.Scanner;

public class IfElseExercise4 {
    public static void main(String[] args) {
        /*
        4、编写程序：由键盘输入三个整数分别存入变量num1、num2、num3，实现从小到大输出三个整数。
         */
        Scanner input = new Scanner(System.in);

        System.out.print("请输入3个整数（用空格分割）：");
        int num1 = input.nextInt();
        int num2 = input.nextInt();
        int num3 = input.nextInt();

        /*
        穷举法：6种可能
            num1 <= num2 <= num3
            num1 <= num3 <= num2

            num2 <= num1 <= num3
            num2 <= num3 <= num1

            num3 <= num1 <= num2
            num3 <= num2 <= num1
         */
        if( num1 <= num2 && num2 <= num3){
            System.out.println(num1 + "<=" + num2 + "<=" + num3);
        }else if( num1 <= num3 && num3 <= num2){
            System.out.println(num1 + "<=" + num3 + "<=" + num2);
        }else if( num2 <= num1 && num1 <= num3){
            System.out.println(num2 + "<=" + num1 + "<=" + num3);
        }else if( num2 <= num3 && num3 <= num1){
            System.out.println(num2 + "<=" + num3 + "<=" + num1);
        }else if( num3 <= num1 && num1 <= num2){
            System.out.println(num3 + "<=" + num1 + "<=" + num2);
        }else{
            System.out.println(num3 + "<=" + num2 + "<=" + num1);
        }

        input.close();

    }
}

java

import java.util.Scanner;

public class IfElseExercise4_2 {
    public static void main(String[] args) {
        /*
        4、编写程序：由键盘输入三个整数分别存入变量num1、num2、num3，实现从小到大输出三个整数。
         */
        Scanner input = new Scanner(System.in);

        System.out.print("请输入3个整数（用空格分割）：");
        int num1 = input.nextInt();
        int num2 = input.nextInt();
        int num3 = input.nextInt();

        /*
        技巧：
        （1）先找出最小值 min
        （2）找出最大值  max
        （3）找出中间值 middle
         */
       int min = num1 <= num2 ? num1 : num2;
       min = min <= num3 ? min : num3;

       int max = num1 >= num2 ? num1 : num2;
       max = max >= num3 ? max : num3;

       int middle = num1 + num2 + num3 - min - max;
       System.out.println(min +"<=" + middle +"<=" + max);

       input.close();

    }
}

java

import java.util.Scanner;

public class IfElseExercise4_3 {
    public static void main(String[] args) {
        /*
        4、编写程序：由键盘输入三个整数分别存入变量num1、num2、num3，实现从小到大输出三个整数。
         */
        Scanner input = new Scanner(System.in);

        System.out.print("请输入3个整数（用空格分割）：");
        int num1 = input.nextInt();
        int num2 = input.nextInt();
        int num3 = input.nextInt();

        /*
        冒泡排序的思想：
            相邻元素比较，如果前面的元素比后面的元素大，就交换它们。
            n个数，需要比较n-1轮
            以3个数为例：
                第一轮：
                    第一个数与第二个数比较
                    第二个数与第三个数比较
                    最终结果只能保证最大的到达最后
                第二轮：
                    第一个数与第二个数比较
         */
        if (num1 > num2) {
            int temp = num1;
            num1 = num2;
            num2 = temp;
        }
        if (num2 > num3) {
            int temp = num2;
            num2 = num3;
            num3 = temp;
        }
        if (num1 > num2) {
            int temp = num1;
            num1 = num2;
            num2 = temp;
        }
        System.out.println(num1 + "<=" + num2 + "<=" + num3);


        input.close();

    }
}

java

import java.util.Scanner;

public class IfElseExercise4_4 {
    public static void main(String[] args) {
        /*
        4、编写程序：由键盘输入三个整数分别存入变量num1、num2、num3，实现从小到大输出三个整数。
         */
        Scanner input = new Scanner(System.in);

        System.out.print("请输入3个整数（用空格分割）：");
        int num1 = input.nextInt();
        int num2 = input.nextInt();
        int num3 = input.nextInt();

        /*
        两两讨论法
         */
        if(num1<=num2){
            if(num3 <= num1){
                System.out.println(num3 +"<=" + num1 +"<=" + num2);
            }else if(num2 <= num3){
                System.out.println(num1 +"<=" + num2 +"<=" + num3);
            }else{
                System.out.println(num1 +"<=" + num3 +"<=" + num2);
            }
        }else{
            //num2 < num1
            if(num3 <= num2){
                System.out.println(num3 +"<=" + num2 +"<=" + num1);
            }else if(num1 <= num3){
                System.out.println(num2 +"<=" + num1 +"<=" + num3);
            }else{
                System.out.println(num2 +"<=" + num3 +"<=" + num1);
            }
        }


        input.close();

    }
}

3.3 分支结构之选择结构

关键词：switch-case

3.3.1 传统的 switch-case 语句（掌握）

语法格式：

java

switch(表达式){
    case 常量值1:
        语句1;
        【break;】
    case  常量值2:
        语句2;
        【break;】
    ....
    【
     default:
        语句;
            】
}

和柴老师约定，笔记中【】代表可选

执行的特点：

（1）入口

A：先找 case，如果有 case 的常量值与它匹配，就从这个 case 进入

B：所有 case 都不匹配，就找 default

（2）出口

A：先找 break

B：执行完 switch 自然结束

（3）穿透/贯穿：穿透的 switch-case 结构，具有穿透性，如果没有 break，那么可能会从上一个分支穿透到下一个分支继续执行。

java

import java.util.Scanner;

public class SwitchCaseStatementTest {
    public static void main(String[] args) {
        //需求：从键盘输入1个星期的数字[1,7]，然后输出这个星期对应的单词
        Scanner input = new Scanner(System.in);

        System.out.print("请输入星期的数字[1,7]：");
        int week = input.nextInt();

        switch (week){
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            case 3:
                System.out.println("Wednesday");
                break;
            case 4:
                System.out.println("Thursday");
                break;
            case 5:
                System.out.println("Friday");
                break;
            case 6:
                System.out.println("Saturday");
                break;
            case 7:
                System.out.println("Sunday");
                break;
            default://上面的case之外的值都走它
                System.out.println("输入有误！");
                break;
        }

        input.close();
    }
}

3.3.2 switch-case 和 if-else 的对比（掌握）

switch-case 效率高，if-else 效率低
if-else 适用性更广，switch-case 有局限性
- switch-case 只能与固定的几个常量值比较，而 if-else 可能是任意条件
- switch-case 的表达式的类型有局限，只支持：byte,short,char,int 四种基本数据类型及其它们的包装类（包装类在后面讲解）、String、枚举（关于枚举后面再讲解）
switch-case 有穿透性，有时候可以利用穿透性，简化代码。

java

import java.util.Scanner;

public class SwitchCaseStatementTest2 {
    public static void main(String[] args) {
        //需求：从键盘输入年、月、日，计算这一天是这一年的第几天
        //例如：2025-6-28，是这一年的第179
        //31 + 28 + 31 + 30 + 31 + 28

        Scanner input = new Scanner(System.in);

        System.out.print("请输入年：");
        int year = input.nextInt();

        System.out.print("请输入月：");
        int month = input.nextInt();

        System.out.print("请输入日：");
        int day = input.nextInt();

        /*
        （1）累加[1, month-1]的所有满月天数
        （2）加第month月的day天
        （3）考虑：如果是闰年，2月是29天
         */
        int days = 0;
        /*if(month==1){
            days += day;
        }else if(month==2){
            days += 31 + day;
        }else if(month == 3){
            days += 31 + 28 + day;
        }else if(month == 4){
            days += 31 + 28 + 31 +  day;
        }。。。
        //上面的写法，能实现，但是有点麻烦*/

        switch (month) {
            case 12:
                days += 30;//30是11月的满月天数
            case 11:
                days += 31;//31是10月的满月天数
            case 10:
                days += 30;//30是9月的满月天数
            case 9:
                days += 31;//31是8月的满月天数
            case 8:
                days += 31;//31是7月的满月天数
            case 7:
                days += 30;//30是6月的满月天数
            case 6:
                days += 31;//31是5月的满月天数
            case 5:
                days += 30;//30是4月的满月天数
            case 4:
                days += 31;//31是3月的满月天数
            case 3:
                days += year % 4 == 0 && year % 100 != 0 || year % 400 == 0 ? 29 : 28;//28或29是2月的满月天数
            case 2:
                days += 31;//31是1月的满月天数
            case 1:
                days += day;
        }
        System.out.println(year + "年" + month + "月" + day + "日是这一年的第" + days + "天");

        input.close();
    }
}

3.3.3 switch-case 新特性（掌握）

1、案例 1

语法格式：

java

switch(表达式){
    case 常量值1 ->
        语句1;
    case  常量值2 ->
        语句2;
    ....
    【
     default ->
        语句;
            】
}

注意：

case 后面的冒号：改为箭头 ->
不需要 break，就可以避免穿透

java

import java.util.Scanner;

public class SwitchCaseExpressTest {
    public static void main(String[] args) {
        //需求：从键盘输入1个星期的数字[1,7]，然后输出这个星期对应的单词
        Scanner input = new Scanner(System.in);

        System.out.print("请输入星期的数字[1,7]：");
        int week = input.nextInt();

        switch (week) {
            case 1 -> System.out.println("Monday");
            case 2 -> System.out.println("Tuesday");
            case 3 -> System.out.println("Wednesday");
            case 4 -> System.out.println("Thursday");
            case 5 -> System.out.println("Friday");
            case 6 -> System.out.println("Saturday");
            case 7 -> System.out.println("Sunday");
//            default -> System.out.println("输入有误！");
        }

        input.close();
    }
}

2、案例 2

语法格式：

java

变量 = switch(表达式){
    case 常量值1 ->
        结果值;
    case  常量值2 ->
        结果2;
    ....
     default ->
        结果n;

}

注意：把整个 switch-case 当成一个表达式，给变量赋值，此时必须有 default 分支，返回默认值。

java

import java.util.Scanner;

public class SwitchCaseExpressTest2 {
    public static void main(String[] args) {
        //需求：从键盘输入1个星期的数字[1,7]，然后输出这个星期对应的单词
        Scanner input = new Scanner(System.in);

        System.out.print("请输入星期的数字[1,7]：");
        int week = input.nextInt();

        //如果switch-case用作表达式，那么default是必选的
        String weekName = switch (week) {
            case 1 -> "Monday";
            case 2 -> "Tuesday";
            case 3 -> "Wednesday";
            case 4 -> "Thursday";
            case 5 -> "Friday";
            case 6 -> "Saturday";
            case 7 -> "Sunday";
            default -> "输入有误！";
        };
        System.out.println("weekName = " + weekName);

        input.close();
    }
}

3、案例 3

语法格式：

java

变量 = switch(表达式){
    case 常量值1 ->
            {
                语句1;
                yield 结果值1;
            }
    case  常量值2 ->
        	{
                语句2;
                yield 结果值1;
            }
    ....
     default ->
        	{
                语句n;
                yield 结果值n;
            }

}

注意：

如果 switch-case 作为表达式给变量赋值，同时又想要在 case 或 default 后面写其他语句，那么需要在分支后面加{}，结果值用 yield 返回

java

import java.util.Scanner;

public class SwitchCaseExpressTest3 {
    public static void main(String[] args) {
        //需求：从键盘输入1个星期的数字[1,7]，然后输出这个星期对应的单词
        Scanner input = new Scanner(System.in);

        System.out.print("请输入星期的数字[1,7]：");
        int week = input.nextInt();

        //如果switch-case用作表达式，那么default是必选的
        String weekName = switch (week) {
            case 1 ->{
                System.out.println("星期一是最痛苦的一天！");
               yield  "Monday";
            }
            case 2 -> "Tuesday";
            case 3 -> "Wednesday";
            case 4 -> "Thursday";
            case 5 -> "Friday";
            case 6 -> "Saturday";
            case 7 -> "Sunday";
            default -> {
                System.out.println("输入有误！");
                yield "";//yield是一个上下文关键字，不是全局关键字
            }

        };
        System.out.println("weekName = " + weekName);

        input.close();
    }
}

4、案例 4

语法格式：

java

switch(表达式){
    case 常量值1,常量值2,常量值3 ->
        语句1;
    case  常量值4,常量值5,常量值6 ->
        语句2;
    ....
    【
     default ->
        语句;
            】
}

注意：

在 JDK17 版本，case 后面可以写多个常量值，用逗号分割（JDK11、JDK8 不支持）

java

import java.util.Scanner;

public class SwitchCaseExpressTest4 {
    public static void main(String[] args) {
        //从键盘输入月份的数字，然后输出它对应的季节。
        //3,4,5春季，6,7,8夏季,9,10,11秋季,12,1,2冬季
        Scanner input = new Scanner(System.in);

        System.out.print("请输入月份值[1,12]：");
        int month = input.nextInt();

        switch (month){
            case 3,4,5 -> System.out.println("春季");
            case 6,7,8 -> System.out.println("夏季");
            case 9,10,11 -> System.out.println("秋季");
            case 12,1,2 -> System.out.println("冬季");
            default -> System.out.println("错误");
        }
    }
}

3.3.4 练习题

java

import java.util.Scanner;

public class SwitchCaseExercise2 {
    public static void main(String[] args) {
        /*
        2、赌数游戏：随机产生3个1-6的整数，
        如果三个数相等，那么称为“豹子”，
        如果三个数之和大于9，称为“大”，
        如果三个数之和小于等于9，称为“小”，
        用户从键盘输入押的是“豹子”、“大”、“小”，并判断是否猜对了
        提示：随机数  Math.random()产生 [0,1)范围内的小数

        Math.random()产生 [0,1)范围内的小数
         Math.random() * 6  产生 [0,6)范围内的小数
         Math.random() * 6 + 1  产生 [1,7)范围内的小数
         (int)( Math.random() * 6 + 1)
         */

        int a =  (int)( Math.random() * 6 + 1);
        int b =  (int)( Math.random() * 6 + 1);
        int c =  (int)( Math.random() * 6 + 1);
        System.out.println("a = " + a);
        System.out.println("b = " + b);
        System.out.println("c = " + c);

        /*Random random = new Random();
        int x = random.nextInt(1, 7);
        int y = random.nextInt(1, 7);
        int z = random.nextInt(1, 7);
        System.out.println("x = " + x);
        System.out.println("y = " + y);
        System.out.println("z = " + z);*/

        Scanner input = new Scanner(System.in);
        System.out.print("请猜（豹子、大、小）：");
        String guess = input.next();

        /*
        switch (guess){
            case "豹子" -> {
                if (a == b && b == c) {
                    System.out.println("猜对了");
                } else {
                    System.out.println("猜错了");
                }
            }
            case "大" -> {
                if (a+b+c>9) {
                    System.out.println("猜对了");
                } else {
                    System.out.println("猜错了");
                }
            }
            case "小" -> {
                if (a+b+c<=9) {
                    System.out.println("猜对了");
                } else {
                    System.out.println("猜错了");
                }
            }
        }

         */

        boolean result = switch (guess){
            case "豹子" -> a==b&&b==c;
            case "大" -> a+b+c>9;
            case "小" -> a+b+c<=9;
            default -> false;
        };
        System.out.println(result ? "猜对了" : "猜错了");
    }
}

java

import java.util.Scanner;

public class SwitchCaseExercise2_2 {
    public static void main(String[] args) {
        /*
        2、赌数游戏：随机产生3个1-6的整数，
        如果三个数相等，那么称为“豹子”，
        如果三个数之和大于9，称为“大”，
        如果三个数之和小于等于9，称为“小”，
        用户从键盘输入押的是“豹子”、“大”、“小”，并判断是否猜对了
        提示：随机数  Math.random()产生 [0,1)范围内的小数

        Math.random()产生 [0,1)范围内的小数
         Math.random() * 6  产生 [0,6)范围内的小数
         Math.random() * 6 + 1  产生 [1,7)范围内的小数
         (int)( Math.random() * 6 + 1)
         */

        int a =  (int)( Math.random() * 6 + 1);
        int b =  (int)( Math.random() * 6 + 1);
        int c =  (int)( Math.random() * 6 + 1);
        System.out.println("a = " + a);
        System.out.println("b = " + b);
        System.out.println("c = " + c);

        Scanner input = new Scanner(System.in);
        System.out.print("请猜（豹子、大、小）：");
        String guess = input.next();

        /*
        String不是基本数据类型。基本数据类型是 byte,short,int,long,float,double,char,boolean。
        只有基本数据类型的值  是否相等用 == 。
        像字符串这种引用数据类型比较是否相等应该用equals
         */
        /*if(guess == "豹子"){
            System.out.println(a==b && b==c ? "猜对了" : "猜错了");
        }else if(guess == "大"){
            System.out.println(a+b+c>9 ? "猜对了" : "猜错了");
        }else if(guess == "小"){
            System.out.println(a+b+c<=9 ? "猜对了" : "猜错了");
        }else{
            System.out.println("猜错了");
        }*/
        if(guess.equals("豹子")){
            System.out.println(a==b && b==c ? "猜对了" : "猜错了");
        }else if(guess.equals("大")){
            System.out.println(a+b+c>9 ? "猜对了" : "猜错了");
        }else if(guess.equals("小")){
            System.out.println(a+b+c<=9 ? "猜对了" : "猜错了");
        }else{
            System.out.println("猜错了");
        }
    }
}

一、晨考 ​

二、复习 ​

三、流程控制语句结构 ​

3.1 顺序结构 ​

3.1.1 输出语句（掌握） ​

3.1.2 输入语句（掌握） ​

3.1.3 IDEA 安装通易灵码插件 ​

3.1.4 输入的复杂情况（拓展） ​

3.1.5 IDEA 自动导包设置 ​

3.2 分支结构之条件判断 ​

3.2.1 单分支条件判断（掌握） ​

3.2.2 双分支条件判断（掌握） ​

3.2.3 多分支条件判断（掌握） ​

3.2.4 条件判断的嵌套使用（掌握） ​

3.2.5 练习题 ​

1、彩票 ​

2、3 个数排序 ​

3.3 分支结构之选择结构 ​

3.3.1 传统的 switch-case 语句（掌握） ​

3.3.2 switch-case 和 if-else 的对比（掌握） ​

3.3.3 switch-case 新特性（掌握） ​

1、案例 1 ​

2、案例 2 ​

3、案例 3 ​

4、案例 4 ​

3.3.4 练习题 ​

一、晨考

二、复习

三、流程控制语句结构

3.1 顺序结构

3.1.1 输出语句（掌握）

3.1.2 输入语句（掌握）

3.1.3 IDEA 安装通易灵码插件

3.1.4 输入的复杂情况（拓展）

3.1.5 IDEA 自动导包设置

3.2 分支结构之条件判断

3.2.1 单分支条件判断（掌握）

3.2.2 双分支条件判断（掌握）

3.2.3 多分支条件判断（掌握）

3.2.4 条件判断的嵌套使用（掌握）

3.2.5 练习题

1、彩票

2、3 个数排序

3.3 分支结构之选择结构

3.3.1 传统的 switch-case 语句（掌握）

3.3.2 switch-case 和 if-else 的对比（掌握）

3.3.3 switch-case 新特性（掌握）

1、案例 1

2、案例 2

3、案例 3

4、案例 4

3.3.4 练习题