抉择构造

你好，欢送回来，我是彭彭！HAKUNA MATATA！！！

在数据和运算的根底上，当初又有了新的需要：流程管制。代码的执行流程个别不会一竿子到底的执行上来，很多时候会依据数据的变动抉择适合的走向，甚至改变程序的运行后果。从这节课开始，我为你介绍 Java 语言的流程控制结构，包含 抉择构造 和循环构造 两局部。

程序的后果跟代码的执行程序严密相干，通过应用一些特定的语句控制代码的执行程序从而实现特定的性能，这就是 流程控制结构。其实，Java 程序的流程管制，不仅仅是抉择构造和循环构造这两种，还有一种默认的构造，叫程序构造，即程序依照代码的程序从上往下、从左往右顺次执行的代码构造。程序构造是最简略的流程控制结构，不须要特定的管制语句，程序的大多数代码都是这样执行的：

这种构造过于简略，就不须要破费篇幅去介绍了。

这门课介绍抉择构造，下门课介绍循环构造。

抉择构造也叫判断构造 / 分支构造，也就是说，依据判断条件是否成立，抉择执行对应的分支。所以，抉择构造个别由两大部分组成：判断条件和分支。判断条件和分支都有可能会有多个，依据不同的条件去执行对应的分支，实现简单的业务逻辑。通过本节课程的学习，你将可能：

​ 应用 if 语句来管制你的 Java 程序的执行流程

​ 应用 switch 语句来管制你的 Java 程序的执行流程

​ 应用扫描器（Scanner）对象在控制台输出数据

课程内容如下：

• if 语句：如果爱，请深爱
• ​ Scanner 扫描器：我是数据探险家
• ​ switch 语句：排排坐，吃果果

第一关 if 语句：如果爱，请深爱

1.1 抉择构造的概念和 if 格局

抉择构造要先判断条件是否成立，条件成立则执行一部分代码，不成立则执行另外一部分或完结代码，所以抉择构造也叫 判断构造。判断条件个别是一个或多个关系表达式，当然，也不排除简单的逻辑表达式，因为它们执行的后果都是 boolean 类型的值。

看一段代码：

public class Test{public static void main(String[] args) {System.out.println("开始执行");
        // 定义两个 int 类型的变量，它们的值都是 10
        int a = 10;
        int b = 10;
    
        if (a == b) { // 判断两个变量是否相等，很显著，条件是成立的
            // 如果能走这里, 阐明条件成立.
            System.out.println("a 和 b 是相等的");
        }
        System.out.println("完结执行");
    }
}

这段代码的开始和完结别离打印了一些提示信息，两头才是咱们关注的内容。关键字 if 之后是一对小括号，外面是一个关系表达式，而后紧跟着一对大括号（花括号），这就是 if 语句的根本格局，它意味着：如果 if 之后小括号里关系表达式返回后果为 true，那么就执行大括号外面的代码——一对大括号包起来的代码叫做代码块，否则就跳过大括号外面的代码，间接执行最初的输入语句“完结执行”。很显著，a == b 是成立的，所以，这段代码的输入后果是：

开始执行
a 和 b 是相等的
完结执行

反之，如果把 a == b 改成这样的条件 a > b，判断条件将不成立，

public class Test{public static void main(String[] args) {System.out.println("开始执行");
        // 定义两个 int 类型的变量，它们的值都是 10
        int a = 10;
        int b = 10;

        if (a > b) { // 判断两个变量是否相等，很显著，条件是成立的
            // 如果能走这里, 阐明条件成立.
            System.out.println("a 和 b 是相等的");
        }
        System.out.println("完结执行");
    }
}

执行后果就变成了：

开始执行
完结执行

从下面代码的运行成果能够失去以下两个论断，第一，if 语句的根本格局是：

     // 第一种格局：if (关系表达式) {// 语句体}

第二，它的执行流程：

也就是说，当关系表达式返回后果为 true 时，就会执行 if 代码块外面的语句体，否则，程序就跳过了 if 语句，间接执行到完结。这是最简略的 if 语句格局，它代表了“如果——那么”的执行逻辑。

考一考：if 语句应用

看程序，说后果：

public class Test{public static void main(String[] args) {
        int x = 1, y = 1;
        if (x++ == 2 && ++y == 2) {x = 7;}
        System.out.println("x =" + x + ", y =" + y);
    }
}    

答案：x = 2, y = 1

1.2 if 和 else 格局

如果爱，请深爱，否则，请放开。条件不成立，并不代表程序就肯定该完结。这样的构造怎么实现呢？再看一段代码：

public class Test{public static void main(String[] args) {System.out.println("开始执行");
        // 定义两个 int 类型的变量，它们的值都是 10
        int a = 10;
        int b = 10;
    
        if (a == b) { // 如果爱
            System.out.println("请深爱");
        } else { // 否则
            System.out.println("请放开");
        }
        System.out.println("完结执行");
    }
}

在 if 语句的代码块之后，我又加了一个 else 代码块。此时 a == b 的条件是成立的，会打印出“请深爱”，然而 else 代码块的内容不会输入。

开始执行
请深爱
完结执行

else 代码块没有执行。当初，咱们如法炮制，还是把判断条件改了，变成：a > b，这样条件就不成立了，else 代码块会执行吗？看看输入后果：

public class Test{public static void main(String[] args) {System.out.println("开始执行");
        // 定义两个 int 类型的变量，它们的值都是 10
        int a = 10;
        int b = 10;
    
        if (a > b) { // 如果爱
            System.out.println("请深爱");
        } else { // 否则
            System.out.println("请放开");
        }
        System.out.println("完结执行");
    }
}

开始执行
请放开
完结执行

Bingo！if 代码块和 else 代码块是互斥的，我发现了一个宝藏！

没错，这里的 if 和 else 组成了一个残缺的抉择构造，它们只可能执行其中的一个分支，永远不可能同时执行两个局部。那么，依据下面的代码，咱们失去了 if 语句的第二种格局和它的执行流程：

    // 第二种格局：if (关系表达式) {// 语句体 1} else {// 语句体 2}

执行流程：

如果 if 语句的关系表达式返回后果为 true，那么就执行紧跟在 if 之后的代码块，也就是“语句体 1”，否则，执行 else 之后的代码块，也就是“语句体 2”，最初程序运行完结。这是 if 语句的第二种格局，它代表了“如果——那么——否则”的执行逻辑。

“看着这个节奏，if 语句如同还没介绍完。。。”

“你真聪慧。”

1.3 else if 格局

人工智能这么火爆，咱们也研发了一个智能机器人“小黑同学”。小黑同学既聪慧，又有礼貌，无论你什么时候去聊骚她，她都会先依据当初的工夫跟你打招呼。比方当初是 0 -12 点之间，她就会跟你说“上午好”，13-18 点之间，她就会说“下午好”，如果是 18-24 点之间，她就会说“早晨好”，如果你随便的跟她说个不在这些范畴的工夫，她还会怄气呢！不信你试试：

public class Test{public static void main(String[] args) {
        // 定义变量, 记录以后工夫
        int time = 18; 

        // 小黑依据你的工夫和你打招呼.
        if (time >= 0 && time <= 12) {System.out.println("小黑同学说: 上午好");
        } else if (time >= 13 && time <= 18) {System.out.println("小黑同学说: 下午好");
        } else if (time >= 19 && time <= 24) {System.out.println("小黑同学说: 早晨好");
        } else {
            // 你说的工夫太随便，人家会怄气！System.out.println("小黑同学说: 买了否冷, 我不意识这个工夫!");
        }
    }
}

输入后果：

小黑同学说: 下午好

if 见过了，else 也见过了，然而 else if 没见过，看起来还很高大上的样子呢！

else if 的字面意思是“否则，如果”，也就是当后面的 if 条件不成立，就看看这个 else if 前面的条件，如果还不成立，就持续往下找前面的 else if 条件，任意一个 if 或者 else if 判断成立，就会执行外面的代码，而后跳出整个 if 抉择构造，否则，就始终到所有的判断都不成立，才会去执行最初的 else 前面的代码块，比方把变量 time 的值改成 -1 或者 25，

public class Test{public static void main(String[] args) {
        // 定义变量, 记录以后工夫
        int time = -1; 

        // 小黑依据你的工夫和你打招呼.
        if (time >= 0 && time <= 12) {System.out.println("小黑同学说: 上午好");
        } else if (time >= 13 && time <= 18) {System.out.println("小黑同学说: 下午好");
        } else if (time >= 19 && time <= 24) {System.out.println("小黑同学说: 早晨好");
        } else {
            // 你说的工夫太随便，人家会怄气！System.out.println("小黑同学说: 买了否冷, 我不意识这个工夫!");
        }
    }
}

执行后果就变成了：

小黑同学说: 买了否冷, 我不意识这个工夫!

而其它的工夫范畴（0-24），这段代码就会输入对应的话。

下面的代码应用了 if 语句的第三种格局：

    // 第三种格局：if (关系表达式 1) {// 语句体 1} else if (关系表达式 2) {// 语句体 2}  // …
    else {// 语句体 n +1}

这种格局看起来有些简单，然而了解起来并不难，上个图，就更容易了解这个格局的执行流程了：

我把这个流程图示意的意思写下来，以便你对照着了解：

执行流程:
    先判断关系表达式 1, 看其是否成立(true: 成立, false: 不成立).
     成立,   则执行语句体 1,
     不成立, 则判断关系表达式 2, 看其是否成立.
         成立, 执行语句体 2,
         不成立, 则判断关系表达式 3, 看其是否成立.
 ...
 顺次类推，判断所有的条件，如果关系表达式 n 成立, 则执行语句体 n, 

    否则执行语句体 n + 1

肯定要留神的是，无论 if 语句整个构造中的条件有多少个，每一个条件都是并列关系，它们只能执行其中一个，或者执行最初的 else 分支。还有就是，通过 if 语句的多种格局发现，除了第一个 if 判断条件之外，其它的 else if 和 else 代码块都是能够省略的，它们都是“非必须的”，在你编写代码的时候，到底要不要应用那么多的条件，以及要不要 else 分支，齐全取决于：你的情绪。

此外，if 语句的判断条件或者 else 前面的代码块，有的时候内容非常简单——只有一行代码，这个时候，能够省略大括号：

public static void main(String[] args) {if (5 > 3) // 代码块中只有一行代码时，能够省略大括号，然而不倡议这么做
        System.out.println("5 大于 3 成立");
    else 
        System.out.println("5 大于 3 不成立");
}

尽管从语法的角度上能够这样做，然而有教训的开发者们，却不倡议咱们这样做，因为代码块里随时有可能减少新的内容，如果遗记增加上大括号，那将是一场劫难。

考一考：if 语句应用

1. 需要：给定两个变量，应用 if 语句判断较大值，并输入相应信息：

    int a = 3, b = 5;

答案：

public class Test{public static void main(String[] args) {
        int a = 3, b = 5;
        if (a > b) {System.out.println("a 大于 b");
        } else if (a == b) {System.out.println("a 等于 b");
        } else {System.out.println("a 小于 b");
        }
    }
}

2. 需要：依据学生问题输入对应级别

• 90-100 皇帝
• 80-90 宰相
• 70-80 大臣
• 60-70 县官
• 60 以下 草民

答案：

public class Test{public static void main(String[] args) {
        int score = 83;   // 定义学生的问题

        // 依据学生的问题, 和题设的条件进行比照, 并依照要求进行输入即可.
        if (score >= 90 && score <= 100) {System.out.println("皇帝");
        } else if (score >= 80 && score < 90) {System.out.println("宰相");
        } else if (score >= 70 && score < 80) {System.out.println("大臣");
        } else if (score >= 60 && score < 70) {System.out.println("县官");
        } else if (score >= 0 && score < 60) {System.out.println("草民");
        } else { // 留神非法数据的解决
            System.out.println("没有这样的问题, 你是从火星来的吧?");
        }
    }
}

第二关 Scanner 扫描器：我是数据探险家

理论开发中的数据比方用户登录信息，订单状态等等，简直都是动静获取的，而不是像咱们下面的代码中间接定义成固定值：int score = 83;。尽管当初咱们还无奈间接像生产环境那样获取数据，然而 Java 语言给咱们提供了一个可供模仿的工具：Scanner。Scanner是一个扫描器，它能够扫描咱们在控制台录入的数据，因而，咱们能够通过它来模仿动静获取数据的成果。

那么，如何应用 Scanner 呢？

Scanner 在 Java 语言中是一个类（对于类的概念，到【面向对象】章节具体介绍），你能够把它看成是具备肯定性能的一个工具，它的性能就是：接管咱们从控制台录入的数据，而后把这些数据交给程序去解决。应用 Scanner 进行控制台录入数据，须要三步：

​ 第一步：导包。其实是导入扫描器这个类

    import java.util.Scanner; // 导入扫描器这个类

​ 第二步：创立扫描器对象。扫描器这个类，须要以对象的模式工作

    // 扫描器对象的名字叫 sc，你也能够依据标识符的命名规定去定义其它的名字，比方 scanner、next 等等
    Scanner sc = new Scanner(System.in);

​ 第三步：接收数据。应用 对象. 办法名() 这种格局来获取咱们录入的数据，并将后果赋值给一个变量。

    int a = sc.nextInt();

写一段代码试试成果：

// 1. 导包
import java.util.Scanner;
public class Test {public static void main(String[] args) {
        // 2. 创立键盘录入对象.
        Scanner sc = new Scanner(System.in);

        System.out.println("请输出一个整数:"); // 退出一句提示信息
        // 3. 接收数据.
        int i = sc.nextInt();

        // 将用户录入的数据打印到管制台上.
        System.out.println("i:" + i);
    }
}

应用 Scanner 的三个步骤缺一不可。第一、二步都是固定格局，除了扫描器的名字 sc 能够改成你喜爱的标识符之外，其它的代码都不能改变，而且，尤其要留神第一步导包代码的地位：在类的下面，而第二、三步都在 main 办法外面。

程序执行到第三步的时候，控制台会显示闪动的光标，此时程序正在期待咱们录入数据（整个程序是阻塞的）：

此时，咱们能够应用键盘录入数据，问题是：录入什么数据呢？nextInt() 办法的意思是“从控制台获取一个 int 类型的整数”，所以，咱们能够输出一个数字试试：

很快，控制台就把咱们输出的数字 10 给从新打印进去了。这个过程产生了什么？回到下面代码：当咱们在控制台输出 10 之后，按回车键，此时，nextInt() 办法扫描到了这个数据，而后把它赋值给变量 i，紧接着，输入语句把变量 i 的值从新打印进去了。这就是扫描器 Scanner 的应用。

回到下面“依据学生问题输入对应级别”的案例，当初咱们能够从控制台录入学生问题，接管到数据之后，再用 if 语句进行判断：sf

// 1. 导包
import java.util.Scanner;
public class Test {public static void main(String[] args) {
        // 2. 创立键盘录入对象.
        Scanner sc = new Scanner(System.in);
        System.out.println("请输出一个整数:");
        // 3. 接收数据.
        int score = sc.nextInt(); // 输出学生的问题
        // 依据学生的问题, 和题设的条件进行比照, 并依照要求进行输入即可.
        if (score >= 90 && score <= 100) {System.out.println("皇帝");
        } else if (score >= 80 && score < 90) {System.out.println("宰相");
        } else if (score >= 70 && score < 80) {System.out.println("大臣");
        } else if (score >= 60 && score < 70) {System.out.println("县官");
        } else if (score >= 0 && score < 60) {System.out.println("草民");
        } else { // 留神非法数据的解决
            System.out.println("没有这样的问题, 你是从火星来的吧?");
        }
    }
}

你可能会说，学生问题不肯定就是整数啊？！没错，如何录入浮点数呢？还有，能够从控制台录入我想说的话吗？

答案是必定的。后面学习到的 Java 语言的八种根本数据类型，除了 char 类型之外，都有对应的接管形式。如果想接管 char 类型数据，能够应用 int 类型的变量来接管，而后再 强制类型转换 成 char 类型；如果想接管你对我爱的表白，就要应用 String 类型了，因为那可能是超过一万字的小作文：

nextByte()：接管 byte 类型的数据。用法示例：byte by = sc.nextByte();

nextShort()：接管 short 类型的数据。用法示例：short sh = sc.nextShort();

nextInt()：接管 int 类型的数据。用法示例：int i = sc.nextInt();

nextLong()：接管 long 类型的数据。用法示例：long lo = sc.nextLong();

nextFloat()：接管 float 类型的数据。用法示例：float fl = sc.nextFloat();

nextDouble()：接管 double 类型的数据。用法示例：double dou = sc.nextDouble();

nextBoolean()：接管 boolean 类型的数据。用法示例：boolean bo = sc.nextBoolean();

nextLine()：接管 String 类型的数据。用法示例：String line = sc.nextLine();

最初，还须要留神的一个点是，当咱们在控制台录入的数据类型与扫描器对象应用的办法期待的类型不匹配，这个时候程序就会报错。比方sc.nextInt() 这行代码期待的是 int 类型，如果咱们输出的是字符串，就会变成这样的后果：

程序报出了一个错，并终止。尽管大部分错误信息咱们看不懂，然而通过 InputMismatchException 这行信息的字面意思，大略也能晓得是“输出不匹配”的问题。精确地说，程序抛出了一个异样（Exception）并终止，这个异样的名字叫做 InputMismatchException，异样信息的最初一行，批示出咱们的代码的第 12 行呈现了问题：int i = sc.nextInt();，意思曾经十分明确了，就是在录入数据的时候产生了类型不匹配的景象。现阶段临时不要求你对“异样”的概念理解更多，你只须要晓得当初程序报错了，是因为输出类型与应用的扫描器办法须要的类型不统一导致的，而且要尽量避免这样的状况产生。

考一考：Scanner 扫描器应用

1. 需要：编写代码，键盘录入两个整数，求它们的和

实现键盘录入性能的步骤：

第一步：导包。

第二步：创立扫描器对象。

第三步：接收数据。

答案：

// 1. 导包
import java.util.Scanner;
public class Test {public static void main(String[] args) {
        // 需要: 键盘录入两个整数, 求它们的和
        // 2. 创立键盘录入对象.
        Scanner sc = new Scanner(System.in);

        // 3. 提醒用户录入数据, 并接管.
        System.out.println("请录入第一个整数:");
        int a = sc.nextInt();
        System.out.println("请录入第二个整数:");
        int b = sc.nextInt();

        // 4. 计算整数和.
        int sum = a + b;

        // 5. 打印后果.
        System.out.println("sum:" + sum);
    }
}

2. 需要：键盘录入两个数据，获取这两个数据的较大值

思路剖析：

​ A：键盘录入的三个步骤：

​ 导包；创立键盘录入对象；获取数据；

​ B：获取两个数据的较大值：if 语句的格局 2 实现

​ C：把较大的后果输入

答案：

import java.util.Scanner;

public class IfDemo {public static void main(String[] args) {
        // 需要: 键盘录入两个数据, 获取这两个数据的最大值
        // 1. 创立键盘录入对象, 以便接管用户录入的数据(蕴含: 导包, 创建对象)
        Scanner sc = new Scanner(System.in);

        // 2. 提醒用户录入两个整数, 并接管
        System.out.println("请录入第一个整数:");
        int a = sc.nextInt();
        System.out.println("请录入第二个整数:");
        int b = sc.nextInt();

        // 3. 定义变量, 记录最大值
        int max;

        // 4. 通过 if 语句的第二种格局, 判断两个整数的最大值
        if (a >= b) {
            // 如果走这里, 阐明 a 大
            max = a;
        } else {
            // 如果走这里, 阐明 b 大
            max = b;
        }

        // 5. 将后果打印到管制台上
        System.out.println("较大值是:" + max);
    }
}

第三关 switch 语句：排排坐，吃果果

if 语句能够实用简直所有的开发场景，然而，当每个分支的判断条件都是 具体值 的时候，应用 if 语句就不如应用 switch 语句更加直观。比方，判断 1 - 7 的整数对应的星期，应用 if 语句和 switch 语句别离来实现：

先看 if 语句的成果：

public class Test{public static void main(String[] args) {
        int weekDay = 1;
        if (weekDay == 1) {System.out.println("星期一");
        } else if (weekDay == 2) {System.out.println("星期二");
        } else if (weekDay == 3) {System.out.println("星期三");
        } else if (weekDay == 4) {System.out.println("星期四");
        } else if (weekDay == 5) {System.out.println("星期五");
        } else if (weekDay == 6) {System.out.println("星期六");
        } else if (weekDay == 7) {System.out.println("星期日");
        } else {System.out.println("我不意识这样的工夫, 你是从火星来的吧?");
        }
    }
}

再来看看应用 switch 语句的成果：

public class Test{public static void main(String[] args) {
        int weekDay = 1;
        switch (weekDay) {
           case 1:
               System.out.println("星期一");
               break;
           case 2:
               System.out.println("星期二");
               break;
           case 3:
               System.out.println("星期三");
               break;
           case 4:
               System.out.println("星期四");
               break;
           case 5:
               System.out.println("星期五");
               break;
           case 6:
               System.out.println("星期六");
               break;
           case 7:
               System.out.println("星期日");
               break;
           default:
               System.out.println("我不意识这样的工夫, 你是从火星来的吧?");
               break;
       }
    }
}

这是 switch 语句的规范格局，两段代码的性能是齐全等价的。仔细观察，应用 switch 语句时，更容易察看到判断条件的具体值和整段代码的清晰构造，这也是之所以呈现 switch 语句的起因。在理论开发中，所有的 switch 构造都能够替换成 if 构造，反之不成立。切记：switch 只实用于判断具体值的分支构造，不适用于判断某一范畴，而 if 都能够。这段代码的执行流程跟 if 构造简直是齐全一样的：

回过头来再比照 if 语句来看下 switch 语句的格局和各局部的含意：

    switch (表达式)  {   // 表达式的取值类型：byte,short,int,char JDK5 当前能够是枚举；JDK7 当前能够是 String
        case 值 1:       // case 前面跟的是要和表达式进行比拟的值，每一个 case 代表一个分支
            语句体 1;     // 语句体局部能够是一条或多条语句
            break;      // 示意中断，完结的意思，能够完结 switch 语句
        case 值 2:
            语句体 2;
            break;
            // ...      // case 能够有很多个
        default:        // 示意所有状况都不匹配的时候，就执行这里的内容，相当于 if 语句的 else 局部
            语句体 n +1;
            break;
    }

switch 关键字相当于 if 关键字，只不过，if 前面小括号里是关系表达式，而 switch 前面小括号里个别是一个变量，而变量的值，与后续每个 case 分支的值进行比照，也就是把“比拟”的动作延后了。switch 前面的“表达式”既然是一个变量，那么它是什么数据类型呢，所有类型都能够吗？答案是否定的。后面咱们提到，switch 适宜判断固定值的状况，也就意味着这些值必须是已知的，换句话说，这些值都应该是常量，比方字面值常量（byte、short、char、int）、String、枚举 等类型。String 类型的每个数据都是字符串常量，所以它能够作为 switch 的表达式类型（JDK7 新个性）； 枚举 是 Java 语言默认反对的一种常量类，所以它也能够作为 switch 的表达式类型（JDK5 新个性）。而 Java 语言的八种根本数据类型里，boolean、long、float、double 临时都不被反对，次要是因为这些类型的数据作为条件进行分支抉择的场景太少，但不排除在后续 JDK 版本里提供相应反对的可能。

case 代表每一个具体的分支，它前面跟具体的值，这里的取值其实是后面“表达式”变量可能的值。如果匹配胜利，则执行这个 case 外面的语句体，否则，持续进行下个 case 的判断，直到任意一个 case 匹配胜利，或者执行 default 局部，default 分支相当于 if 构造最初的 else。语句体能够有多句，就像 if 前面的代码块一样，业务逻辑能够很简单，也能够很简略。

每个 case 的最初个别都会有个 break 语句，代表这个分支的完结，它的作用相似 if 构造的代码块完结标记，程序执行到 break 语句，将会跳出整个 switch 构造。同样的，就像 if 语句的大括号能够省略一样，break 语句也不是必须的，二者有两点区别：第一，if 语句当且仅当代码块只有一行语句时才能够省略大括号，而 case 分支没有这个限度，它能够在领有很多代码的前提下，省略 break 语句；第二，在 if 语句中，执行完分支的代码就肯定会跳出 if 构造，而如果省略了 case 中的 break 语句，执行完以后分支后并不会跳出 switch，而是继续执行后续的 case 或者 default 分支，直到遇到 break 语句跳出，或者执行完 switch 构造残余的所有代码。这种状况实用于多个取值执行雷同的业务逻辑的场景。举个栗子：

需要：输出 1 -12 月份数字，输入对应的节令，如果输出谬误，则打印提示信息

秋季：3，4，5；

冬季：6，7，8；

秋季：9，10，11；

夏季：12，1，2；

残缺代码：

import java.util.Scanner;

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

        System.out.println("请输出月份（1-12）：");
        int month = sc.nextInt();
        switch (month) {
            case 3: // 此分支没有任何内容，也没有 break 语句。下同
            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;
            case 12:
            case 1:
            case 2:
                System.out.println("夏季");
                break;
            default:
                System.out.println("你说的是火星月吗？");
                break;
        }
    }
}

这段代码中，当 case 分支取值为 3、4、6、7、9、10、12、1 等数字的时候，不仅没有任何代码，也没有 break 语句，程序怎么执行的呢？当咱们从控制台输出数字 3，匹配第一个 case 分支胜利，则执行该分支外面的代码——只管没有任何内容，执行完该分支，因为没有 break 语句，此时程序并不会跳出 switch 构造，而是会继续执行后续分支的代码，这就到了 case 4： 这一行，当初代码还须要再做一次判断吗？答案是：不须要了。这就好比你拿着一把钥匙，关上了仓库的某一扇门，进去之后整个仓库的金银珠宝都呈现在你背后，让你轻易拿，难道你还会进来从别的门再进一次？上面这张图兴许有助于你了解这段代码的执行流程：

整个 switch 是一个仓库，每个 case 分支都是一扇进入仓库的门，default 分支是后门，而表达式则是用来打开门的钥匙，表达式的值与任何一扇门匹配，则能够关上这扇门进入仓库，而后金银珠宝随你造。所以，匹配 case 3: 胜利之后，因为没有执行 break 语句，那么就继续执行 case 4 和 case 5 两个分支，直到遇到 case 5 的 break 语句，退出 switch 构造。

switch 语句后半局部内容有些难，须要你仔细阅读这部分常识，并理论运行这些代码才可能了解。

考一考：switch 语句应用

1. 看程序，说后果：

public static void main(String[] args) {
    int x = 2, y = 3;
    switch (x) {
        default:
            y++;
        case 3:
            y++;
            break;
        case 4:
            y++;
    }
    System.out.println("y=" + y);
}

答案：y=5

2. 实现一个简略的计算器，反对加、减、乘、除四个性能。

例如：输出数字 3 和 5，相加后果是 8。（小提示：String 类型的默认值的空常量 null，能够用来判断 String 变量是否被从新赋值）

控制台数据格式：

​ 请输出第一个数字：

​ 3

​ 请输出第二个数字：

​ 5

​ 请按序号输入您的操作（1 加；2 减；3 乘；4 除）：

​ 1

​ 3 + 5 的后果是 8

答案：

import java.util.Scanner;

public class Test {public static void main(String[] args) {Scanner sc = new Scanner(System.in);
        System.out.println("请输出第一个数字：");
        int num1 = sc.nextInt();
        System.out.println("请输出第二个数字：");
        int num2 = sc.nextInt();
        System.out.println("请按序号输入您的操作（1 加；2 减；3 乘；4 除）：");
        int opr = sc.nextInt();

        int result = 0;
        String operate = null; // 字符串类型的默认值，前面如果从新赋值了，阐明执行了正确的操作符
        switch (opr) {
            case 1:
                result = num1 + num2;
                operate = "+";
                break;
            case 2:
                result = num1 - num2;
                operate = "-";
                break;
            case 3:
                result = num1 * num2;
                operate = "*";
                break;
            case 4:
                result = num1 / num2;
                operate = "/";
                break;
            default:
                System.out.println("输出谬误，不反对的操作符：" + opr);
                break;
        }
        if (operate != null) { // 用于判断任意 case 代码失常执行了，而不是执行了 default
            System.out.println(num1 + operate + num2 + "的后果是：" + result);
        }
    }
}

课程总结

最初，对这节课的内容做个总结：

• if 语句的三种格局和它们的执行流程：

     // 第一种格局：if (关系表达式) {// 语句体}

    // 第二种格局：if (关系表达式) {// 语句体 1} else {// 语句体 2}

    // 第三种格局：if (关系表达式 1) {// 语句体 1} else if (关系表达式 2) {// 语句体 2}  // …
    else {// 语句体 n +1}

• switch 语句的规范格局和执行流程：

    switch (表达式)  {   // 表达式的取值类型：byte,short,int,char JDK5 当前能够是枚举；JDK7 当前能够是 String
        case 值 1:       // case 前面跟的是要和表达式进行比拟的值，每一个 case 代表一个分支
            语句体 1;     // 语句体局部能够是一条或多条语句
            break;      // 示意中断，完结的意思，能够完结 switch 语句
        case 值 2:
            语句体 2;
            break;
            // ...      // case 能够有很多个
        default:        // 示意所有状况都不匹配的时候，就执行这里的内容，相当于 if 语句的 else 局部
            语句体 n +1;
            break;
    }

• if 语句适宜做区间值 / 范畴的判断，而 switch 适宜做固定值的判断；
• switch 语句须要判断的所有值都是常量，且在加载 switch 构造的代码时就曾经实现初始化，所以，switch 效率更高；
• 写程序的时候，做数据测试，应该测试这样的几种状况：正确数据 、 谬误数据 、 边界数据。