流程控制-分支结构

# 前言

在生活中，身边存在许多流程控制的例子，例如工厂的生产流水线：成交、设计、制版、印刷、复合、热化、制袋、成品、质检、入库、出货。在生产过程中，例如质检部分，合格就下一步，不合格就重做，这就存在分支。在软件开发中，也存在流程控制。

# 定义

流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。

# 流程结构

其流程控制方式采用结构化程序设计中规定的三种基本流程结果，即：

顺序结构
分支结构
循环结构

# 顺序结构

程序从上到下逐行地执行，中间没有任何判断和跳转。

# 分支结构

根据条件，选择性地执行某段代码。

有if…else和swtich-case两种分支语句。

# 循环结构

根据循环条件，重复地执行某段代码。

有while、do……while、for三种循环语句。

注意：JDK1.5提供了foreach循环，方便的遍历集合、数组元素。

# `if-else`

分支结构中的if-else有时又叫为条件判断结构

# 语法格式

if语句有三种格式：

if(条件表达式){
    执行代码块;
}

1
2
3

if(条件表达式){
    执行代码块1;
}else{
    执行代码块2;
}

1
2
3
4
5

if(条件表达式1){
    执行代码块1;
}else if(条件表达式2){
    执行代码块2;
}
……
else{
    执行代码块n;
}

1
2
3
4
5
6
7
8
9

else结构是可选的。你可以不使用else后面的代码，如果前面if的条件都不符合，那么程序最后也不会执行任何语句。如果是有业务场景需要这么做，那是可行的。
如果多个条件表达式之间是互斥关系（或没有交集的关系），哪个判断和执行语句声明在上面还是下面，不会影响结果。
如果多个条件表达式之间有交集的关系，需要根据实际情况，考虑清楚应该将哪个结构声明在上面。
如果多个条件表达式之间有包含的关系，通常情况下，需要将范围小的声明在范围大的上面，否则范围小的就没机会去执行。
如果if-else结构中的执行语句只有一行时，对应的一对{}是可以省略的。但是不建议这么做，因为可读性不强。而且容易出错。

# 示例1

package ifTest;
public class IfElseTest {
    public static void main(String[] args) {
        int heartBeats = 179;
        if(heartBeats < 60 || heartBeats > 100){
            System.out.println("需要做进一步检查");
        }
        System.out.println("检查结束");
    }
}

1
2
3
4
5
6
7
8
9
10

当心跳回复100以下，就不需要进一步检查了。

# 示例2

package ifTest;

public class IfElseTest2 {
    public static void main(String[] args) {
        int age = 23;
        if (age < 18) {
            System.out.println("你还可以看动画片");
        } else {
            System.out.println("你可以看动作电影了");
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12

# 示例3

package ifTest;

public class IfElseTest2 {
    public static void main(String[] args) {
        int age = 23;
        if (age < 0) {
            System.out.println("你输入的数据非法");
        } else if (age < 18) {
            System.out.println("青少年时期");
        } else if (age < 35) {
            System.out.println("青壮年时期");
        } else if (age < 60) {
            System.out.println("中年时期");
        } else {
            System.out.println("老年时期");
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 练习1

定义三个int型变量并赋值，使用三元运算符或者if-else获取这三个数中的较大数实现

这个练习之前写过，不过是用三元运算符写的：

package ifTest;

import java.util.Random;

public class IfElseTest3 {
    public static void main(String[] args) {
        int m = new Random().nextInt(100);
        System.out.println(m);
        int n = new Random().nextInt(100);
        System.out.println(n);
        int k = new Random().nextInt(100);
        System.out.println(k);
        int max = m > n ? (m>k?m:k) : (n>k?n:k);
        System.out.println("max:" + max);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

现在可以改成if else结构

package ifTest;

import java.util.Random;

public class IfElseTest3 {
    public static void main(String[] args) {
        int m = new Random().nextInt(100);
        System.out.println(m);
        int n = new Random().nextInt(100);
        System.out.println(n);
        int k = new Random().nextInt(100);
        System.out.println(k);
//        int max = m > n ? (m>k?m:k) : (n>k?n:k);
        int max;
        if (m > n) {
            if (m > k) {
                max = m;
            } else {
                max = k;
            }
        } else {
            if (n > k) {
                max = n;
            } else {
                max = k;
            }
        }
        System.out.println("max:" + max);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

# 练习2

定义2个double类型变量并赋值。如果第一个数大于10，并且第二个数小于20，打印两数之和，否则打印两数乘积。

package ifTest;

import java.util.Random;

/**
 * 定义2个double类型变量并赋值。如果第一个数大于10，并且第二个数小于20，打印两数之和，否则打印两数乘积。
 */
public class IfElseTest4 {
    public static void main(String[] args) {
        double m = new Random().nextDouble() * 20;
        System.out.println(m);
        double n = new Random().nextDouble() * 10;
        System.out.println(n);
        if (m > 10 && n < 20) {
            System.out.println("两数之和：" + (m + n));
        } else {
            System.out.println("两数乘积：" + (m * n));
        }

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# 练习3

参加考试，如果成绩为100分，优异，如果成绩80-99分，优良，如果成绩60-80分，中等，其他时再接再厉。请从键盘输入成绩，加以判断，要打印名字和分数。

提示，输入类是java.util.Scanner;

package ifTest;

import java.util.Random;
import java.util.Scanner;

/**
 * 张三参加考试，
 * 如果成绩为100分，优异，
 * 如果成绩80-99分，优良，
 * 如果成绩60-80分，中等，
 * 其他时，再接再厉。
 * 请从键盘输入成绩，加以判断。
 */
public class IfElseTest5 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入名字：");
        // 从键盘获取输入值,把输入值转换为string
        String name = scanner.next();
        System.out.println("请输入考试分数：");
        // 从键盘获取输入值,把输入值转换为int
        int score = scanner.nextInt();
        System.out.println("-------------------");
        System.out.println("名字：" + name);
        System.out.print("成绩：");
        if (score == 100) {
            System.out.println("优异");
        } else if (score >= 80 && score <= 99) {
            System.out.println("优良");
        } else if (score >= 60 && score < 80) {
            System.out.println("中等");
        } else {
            System.out.println("再接再厉！");
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

"C:\Program Files\Java\jdk1.8.0_211\bin\java.exe" "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2020.2.1\lib\idea_rt.jar=54503:C:\Program Files\JetBrains\IntelliJ IDEA 2020.2.1\bin" -Dfile.encoding=UTF-8 -classpath "C:\Program Files\Java\jdk1.8.0_211\jre\lib\charsets.jar;C:\Program Files\Java\jdk1.8.0_211\jre\lib\deploy.jar;C:\Program Files\Java\jdk1.8.0_211\jre\lib\ext\access-bridge-64.jar;C:\Program Files\Java\jdk1.8.0_211\jre\lib\ext\cldrdata.jar;C:\Program Files\Java\jdk1.8.0_211\jre\lib\ext\dnsns.jar;C:\Program Files\Java\jdk1.8.0_211\jre\lib\ext\jaccess.jar;C:\Program Files\Java\jdk1.8.0_211\jre\lib\ext\jfxrt.jar;C:\Program Files\Java\jdk1.8.0_211\jre\lib\ext\localedata.jar;C:\Program Files\Java\jdk1.8.0_211\jre\lib\ext\nashorn.jar;C:\Program Files\Java\jdk1.8.0_211\jre\lib\ext\sunec.jar;C:\Program Files\Java\jdk1.8.0_211\jre\lib\ext\sunjce_provider.jar;C:\Program Files\Java\jdk1.8.0_211\jre\lib\ext\sunmscapi.jar;C:\Program Files\Java\jdk1.8.0_211\jre\lib\ext\sunpkcs11.jar;C:\Program Files\Java\jdk1.8.0_211\jre\lib\ext\zipfs.jar;C:\Program Files\Java\jdk1.8.0_211\jre\lib\javaws.jar;C:\Program Files\Java\jdk1.8.0_211\jre\lib\jce.jar;C:\Program Files\Java\jdk1.8.0_211\jre\lib\jfr.jar;C:\Program Files\Java\jdk1.8.0_211\jre\lib\jfxswt.jar;C:\Program Files\Java\jdk1.8.0_211\jre\lib\jsse.jar;C:\Program Files\Java\jdk1.8.0_211\jre\lib\management-agent.jar;C:\Program Files\Java\jdk1.8.0_211\jre\lib\plugin.jar;C:\Program Files\Java\jdk1.8.0_211\jre\lib\resources.jar;C:\Program Files\Java\jdk1.8.0_211\jre\lib\rt.jar;C:\Projects\java-learning\target\classes" ifTest.IfElseTest5
请输入名字：
张三
请输入考试分数：
58
-------------------
名字：张三
成绩：再接再厉！

Process finished with exit code 0

1
2
3
4
5
6
7
8
9
10

# 练习4

三个整数分别存入变量num1、num2、num3，对它们进行排序（使用if-else if-else），并从小到大输出。

package ifTest;

import java.util.Random;
import java.util.Scanner;

/**
 * 三个整数分别存入变量num1、num2、num3，对它们进行排序（使用if-else if-else），并从小到大输出。
 */
public class IfElseTest6 {
    public static void main(String[] args) {
        int num1 = new Random().nextInt(100);
        int num2 = new Random().nextInt(100);
        int num3 = new Random().nextInt(100);
        if (num1 >= num2) {
            if (num3 >= num1) {
                System.out.println(num2);
                System.out.println(num1);
                System.out.println(num3);
            } else if (num2 >= num3) {
                System.out.println(num3);
                System.out.println(num2);
                System.out.println(num1);
            } else {
                System.out.println(num2);
                System.out.println(num3);
                System.out.println(num1);
            }
        } else {
            if (num3 >= num2) {
                System.out.println(num1);
                System.out.println(num2);
                System.out.println(num3);
            } else if (num1 >= num3) {
                System.out.println(num3);
                System.out.println(num1);
                System.out.println(num2);
            } else {
                System.out.println(num1);
                System.out.println(num3);
                System.out.println(num2);
            }
        }

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

# 练习5

对下列代码，若有输出，指出输出结果。

int x = 4;
int y = 1;
if(x > 2){
    if(y > 2)
        System.out.println(x + y);
    	System.out.println("Finished");
}else
    System.out.println(x);

1
2
3
4
5
6
7
8

输出结果是“Finished”，因为x = 4，大于2，进入第一个条件，但是y < 2所以不会输出x + y，但是省略括号指挥执行一行，后面的语句不属于它的范围内，所以会输出，其实只要把代码括号还原一下就可以了。

还原代码如下：

int x = 4;
int y = 1;
if(x > 2){
    if(y > 2){
        System.out.println(x + y);
    }
    System.out.println("Finished");    
}else{
    System.out.println(x);
}

1
2
3
4
5
6
7
8
9
10

# 练习6

如果把上面的代码改成下面那样，编译能通过吗？如果能过，此时输出结果是？

int x = 4;
int y = 1;
if(x > 2)
    if(y > 2)
        System.out.println(x + y);
		//System.out.println("Finished");
else
    System.out.println(x);

1
2
3
4
5
6
7
8

能过，输出结果是4。因为else其实是跟第二个if配对，还原成代码如下：

int x = 4;
int y = 1;
if(x > 2){
    if(y > 2){
        System.out.println(x + y);
		//System.out.println("Finished");
    }else{
        System.out.println(x);
    }
}

1
2
3
4
5
6
7
8
9
10

# 练习7

对下列代码，若有输出，指出输出结果。

boolean b = true;
if(b == false)
    System.out.println("a");
else if(b)
    System.out.println("b");
else if(!b)
    System.out.println("c");
else
    System.out.println("d");

1
2
3
4
5
6
7
8
9

结果是b。第1个条件表达式返回false，第二个条件表达式返回true，所以是b。

如果写成if(b = false)能编译通过吗？如果能，结果是？

能编译通过，如果能，结果是c。第一个条件表达式返回false，第二个条件表达式返回false，第三个条件表达式返回true，所以c。

# 练习8

编写程序，声明2个int型变量并赋值。判断两数之和，如果大于等50，打印“hello world!”。

package ifTest;

/*
编写程序，声明2个int型变量并赋值。判断两数之和，如果大于等50，打印“hello world!”。
 */
public class IfTest8 {
    public static void main(String[] args) {
        int num1 = 20;
        int num2 = 43;
        if (num1 + num2 >= 50) {
            System.out.println("hello world!");
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 练习9

编写一个程序，获取用户输入狗的年龄，通过程序显示其相当于人类的年龄，如果用户输入负数，请显示一个提示信息。

我家的狗5岁了，5岁的狗相当于人类多大呢？狗的前两年内每一年想大于人类的10.5岁，之后每增加一年就增加4岁。

package ifTest;

import java.util.Scanner;

/*
我家的狗5岁了，5岁的狗相当于人类多大呢？狗的前两年内每一年想大于人类的10.5岁，之后每增加一年就增加4岁。
 */
public class IfTest9 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入狗的年龄：");
        if (!scan.hasNextDouble()) {
            System.out.println("你输入的不是年龄！");
            return;
        }
        double humanAge = 0;
        double dogAge = scan.nextDouble();
        if(dogAge <= 0){
            System.out.println("请输入大于0的数！");
            return;
        }
        if (dogAge <= 2) {
            humanAge = dogAge * 10.5;
        }else{
            humanAge = 2 * 10.5 + (dogAge - 2) * 4;
        }
        System.out.println(dogAge + "岁的狗相当于人类的" + humanAge + "岁");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

以上程序输出结果为：

请输入狗的年龄：
5
5.0岁的狗相当于人类的33.0岁

1
2
3

# 练习10

假设你想开发一个玩彩票的游戏，程序随机地产生一个两位数的彩票，提示用户输入一个两位，然后按照下面的规则判定用户是否能赢。

如果用户输入的数匹配彩票的实际顺序，奖金10000美元。
如果用户输入的所有数字匹配彩票的所有数字，但顺序不一致，奖金3000美元。
如果用户输入的一个数字仅满足顺序情况下匹配彩票的一个数字，奖金1000美元。
如果用户输入的一个数字仅满足非顺序情况下匹配彩票的一个数字，奖金500美元。
如果用户输入的数字没有匹配任何一个数字，则彩票作废。

提示：使用(int)(Math.random()*90 + 10)产生随机数。

Math.random()：[0.1) * 90 => [0.90) + 10 => [10,100) => [10,99]

package ifTest;

import java.util.Scanner;

/**
 * 假设你想开发一个玩彩票的游戏，程序随机地产生一个两位数的彩票，提示用户输入一个两位，然后按照下面的规则判定用户是否能赢。
 * 1. 如果用户输入的数匹配彩票的实际顺序，奖金10000美元。
 * 2. 如果用户输入的所有数字匹配彩票的所有数字，但顺序不一致，奖金3000美元。
 * 3. 如果用户输入的一个数字仅满足顺序情况下匹配彩票的一个数字，奖金1000美元。
 * 4. 如果用户输入的一个数字仅满足非顺序情况下匹配彩票的一个数字，奖金500美元。
 * 5. 如果用户输入的数字没有匹配任何一个数字，则彩票作废。
 * <p>
 * 提示：使用(int)(Math.random()*90 + 10)产生随机数。
 * <p>
 * Math.random()：[0.1)  * 90 => [0.90) + 10 => [10,100) => [10,99]
 *
 * @author SaulJ
 */
public class IfTest10 {
    public static void main(String[] args) {
        int win = (int) (Math.random() * 90 + 10);
        int win1 = win / 10;
        int win2 = win % 10;
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入一个两位数字：");
        if (!scan.hasNextInt()) {
            System.out.println("你输入的不是数字");
            return;
        }
        int guess = scan.nextInt();
        if (guess < 10 || guess > 99) {
            System.out.println("输入的两位数只能在10~99");
            return;
        }
        int guess1 = guess / 10;
        int guess2 = guess % 10;
        //1.如果用户输入的数匹配彩票的实际顺序，奖金10000美元。
        if (win == guess) {
            System.out.println("完全匹配！你中奖了！奖金10000美元！");
        } else if (win1 == guess2 && win2 == guess1) {
            //2.如果用户输入的所有数字匹配彩票的所有数字，但顺序不一致，奖金3000美元。
            System.out.println("匹配，但是顺序不一致，你中奖了！奖金3000美元");
        } else if (win1 == guess1 || win2 == guess2) {
            //3.如果用户输入的一个数字仅满足顺序情况下匹配彩票的一个数字，奖金1000美元。
            System.out.println("输入的一个数字仅满足顺序情况下匹配彩票的一个数字，你中奖了！奖金1000美元");
        } else if (win1 == guess2 || win2 == guess1) {
            //4.如果用户输入的一个数字仅满足非顺序情况下匹配彩票的一个数字，奖金500美元。
            System.out.println("输入的一个数字仅满足非顺序情况下匹配彩票的一个数字，你中奖了！奖金500美元");
        } else {
            //5. 如果用户输入的数字没有匹配任何一个数字，则彩票作废。
            System.out.println("很遗憾，没中奖，彩票作废！");
        }
		System.out.println("彩票数字是："+win);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

# `swtich-case`

swtich-case是分支结构的一种。有时也被划归为一种选择语句。根据表达式的值，switch 语句可以从一系列代码中选出一段去执行。

根据switch表达式中的值，依次匹配各个case中的常量，一旦匹配成功，则进入响应case结构中，调用其执行语句。当调用完执行语句后，则仍然继续向下执行其他case结构的语句，直到遇到break关键字或者此switch-case结构末尾结束为止。

# 语法格式

switch(表达式){
    case 常量1:
        执行语句1;
        break;
    case 常量2:
        执行语句2;
        break;
    ……
   	case 常量n:
        执行语句n;
        break;
    default:
        执行语句;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

在上面的定义中，大家会注意到每个case 均以一个break 结尾。这样可使执行流程跳转至 switch 主体的末

尾。这是构建switch 语句的一种传统方式，但break 是可选的。若省略 break，会继续执行后面的case 语

句的代码，直到遇到一个break 为止。尽管通常不想出现这种情况，但对有经验的程序员来说，也许能够善

加利用。注意最后的default 语句没有 break，因为执行流程已到了 break 的跳转目的地。当然，如果考虑

到编程风格方面的原因，完全可以在default 语句的末尾放置一个break，尽管它并没有任何实际的用处。

目前switch结构中的表达式，只能是如下的6种数据类型之一：byte、short、char、int、枚举类型（JDK5.0新增）、String类（JDK7.0新增）
case之后只能声明常量，不能声明范围。
default是可选的，而且位置是灵活的。不一定要有default。但是实际开发还是要有，并且放到最后。

# 练习1

使用switch把小写的char型转换为大写。只转换abcde，其他的输出“other”。

package switchTest;

import java.util.Scanner;

/**
 * 使用switch把小写的char型转换为大写。只转换abcde，其他的输出“other”。
 */
public class Demo1 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入abcde中的任意一个字符：");
        if (!scanner.hasNext()) {
            System.out.println("无法执行！");
            return;
        }
        String word = scanner.next();
        char c = word.charAt(0);
        switch (c) {
            case 'a':
                System.out.println("A");
                break;
            case 'b':
                System.out.println("B");
                break;
            case 'c':
                System.out.println("C");
                break;
            case 'd':
                System.out.println("D");
                break;
            case 'e':
                System.out.println("E");
                break;
            default:
                System.out.println("other");
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

# 合并Case

如果switch-case结构中的多个case的执行语句相同，则可以考虑进行合并。

使用switch判断随机一个分数（0-100），60分以上合格，否则是不合格。

其实这个用if-else判断更加块

package switchTest;

public class Demo2 {
    public static void main(String[] args) {
        int score = (int) (Math.random() * 101);
        System.out.println("当前分数是: " + score);
        if (score >= 60) {
            System.out.println("合格!");
        } else {
            System.out.println("不合格!");
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

但是既然题目要求了要用switch结构，那么到底怎么做呢？难道要case1~case100吗？

其实有个小技巧，将分数/10，然后用int截尾就可以了。

不合并case的做法：

package switchTest;

public class Demo3 {
    public static void main(String[] args) {
        int score = (int) (Math.random() * 101);
        System.out.println("当前分数是: " + score);
        switch (score / 10) {
            case 0:
                System.out.println("不合格！");
                break;
            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;
            case 8:
                System.out.println("合格！");
                break;
            case 9:
                System.out.println("合格！");
                break;
            case 10:
                System.out.println("合格！");
                break;
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

合并case的做法：

package switchTest;

public class Demo3 {
    public static void main(String[] args) {
        int score = (int) (Math.random() * 101);
        System.out.println("当前分数是: " + score);
        switch (score / 10) {
            case 0:
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
                System.out.println("不合格！");
                break;
            case 6:
            case 7:
            case 8:
            case 9:
            case 10:
                System.out.println("合格！");
                break;
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

事实上，这个不算是新知识点，还记得if(表达式)不加大括号吗？某种意义上，他们就是一样的。只是写法不一样。

另外，上面其实还不是最优解，上面的案例只是展示合并case的方案，下面才是最优解：

package switchTest;

public class Demo3 {
    public static void main(String[] args) {
        int score = (int) (Math.random() * 101);
        System.out.println("当前分数是: " + score);
        switch (score / 60) {
            case 0:
                System.out.println("不合格！");
                break;
            case 1:
                System.out.println("合格！");
                break;
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 练习2

如果 case 语句块中没有 break 语句时，匹配成功后，从当前 case 开始，后续所有 case 的值都会输出。

从键盘上输入2021年的“month”和“day”，要求通过程序输出输入的日期为2021年的第几天。（要用到switch）

分析这道题，关键是要判断月份

package switchTest;

import java.util.Scanner;

/**
 * 从键盘上输入2021年的“month”和“day”，要求通过程序输出输入的日期为2021年的第几天。（要用到switch）
 */
public class Demo4 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入2021年的month：");
        int month = scan.nextInt();
        System.out.println("请输入2021年的day：");
        int day = scan.nextInt();
        int total = 0;
        switch (month) {
            case 12:
                total += 30;
            case 11:
                total += 31;
            case 10:
                total += 30;
            case 9:
                total += 31;
            case 8:
                total += 31;
            case 7:
                total += 30;
            case 6:
                total += 31;
            case 5:
                total += 30;
            case 4:
                total += 31;
            case 3:
                total += 28;
            case 2:
                total += 31;
            case 1:
                total += day;
        }
        System.out.println("输入的日期为2021年的第" + total + "天");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

当case等于1时，就是1月份，第几天直接加上第几天。

当case等于2时，就是2月份，要先把1月份的31天加上，然后再执行case等于1的语句。

当case等于3时，就是3月份，要先把2月份的28天加上，然后再执行case等于2、等于1的语句。

……

当case等于12时，就是12月份，要把11月的30天加上，再执行其他case语句。

不难发现，每个case其实就是累加上个月的天数。

这个案例主要成功验证了这句话：如果 case 语句块中没有 break 语句时，匹配成功后，从当前 case 开始，后续所有 case 的执行语句都会执行。

说明break在switch-case可选的，而且如果不加break，只要匹配了一个case，后续其他所有case的执行语句都会执行。

# 练习3

从键盘分别输入年、月、日，判断这一天是当年的第几天。

注：判断一年是否闰年的标准：

从题干来说，判断是否闰年，有两种方式：

可以被4整除，但不可被100整除
可以被400整除

事实上这个案例只是需要修改当case等于3时，要加的天数，判断是否闰年就可以了

package switchTest;

import java.util.Scanner;

public class Demo5 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入年份：");
        int year = scan.nextInt();
        System.out.println("请输入" + year + "年的month：");
        int month = scan.nextInt();
        System.out.println("请输入" + year + "年的day：");
        int day = scan.nextInt();
        int total = 0;
        switch (month) {
            case 12:
                total += 30;
            case 11:
                total += 31;
            case 10:
                total += 30;
            case 9:
                total += 31;
            case 8:
                total += 31;
            case 7:
                total += 30;
            case 6:
                total += 31;
            case 5:
                total += 30;
            case 4:
                total += 31;
            case 3:
                if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
                    total += 29;
                } else {
                    total += 28;
                }
            case 2:
                total += 31;
            case 1:
                total += day;
        }
        System.out.println("输入的日期为" + year + "年的第" + total + "天");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

2016年3月1日的结果是：

请输入年份：
2016
请输入2016年的month：
3
请输入2016年的day：
1
输入的日期为2016年的第61天

1
2
3
4
5
6
7

2017年3月1日的结果是：

请输入年份：
2017
请输入2017年的month：
3
请输入2017年的day：
1
输入的日期为2017年的第60天

1
2
3
4
5
6
7

# 练习4

使用switch语句该下列if语句

int a = 3;
int x = 100;
if(a == 1)
    x += 5;
else if(a == 2)
    x += 10;
else if(a == 3)
    x += 16;
else
    x += 34;

1
2
3
4
5
6
7
8
9
10

完成代码如下：

package switchTest;

public class Demo7 {
    public static void main(String[] args) {
        int a = 3;
        int x = 100;
        switch (a) {
            case 1:
                x += 5;
                break;
            case 2:
                x += 10;
                break;
            case 3:
                x += 16;
                break;
            default:
                x += 34;
        }
        System.out.println(x);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 练习5

随机一个学生的成绩0-100，存放在变量score中，使用switch根据score的值输出其对应成绩的等级：

score>-90，等级A
70<=score<90，等级B
60<=score<70，等级C
socre<60，等级D

这一题其实使用if-else结构来写最合适，但是既然题目要求用switch-case结构，那么可以通过分数截尾的方法来判断区间

但是如果c等级是60<score<70:等级C，score<=60等级D，那么就不是简单判断了

package switchTest;

/**
 * 随机一个学生的成绩0-100，存放在变量score中，使用switch根据score的值输出其对应成绩的等级：
 *
 * - score>-90，等级A
 * - 70<=score<90，等级B
 * - 60<=score<70，等级C
 * - socre<60，等级D
 */
public class Demo8 {
    public static void main(String[] args) {
        int score = (int) (Math.random() * 101);
        System.out.print("当前分数为：" + score);
        switch (score / 10) {
            case 10:
            case 9:
                System.out.println(" 等级A");
                break;
            case 8:
            case 7:
                System.out.println(" 等级B");
                break;
            case 6:
                System.out.println(" 等级C");
                break;
            default:
                System.out.println(" 等级D");
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

# 小结

凡是可以使用switch-case的结构都可以转换if-else结构，反之，不成立。

switch-case不适用于浮点型，布尔型。

当选择分支结构时，当发现既可以使用switch-case，又可以是用if-else时，如果switch表达式的取值情况不太多，优先选择switch-case，否则还是用if-else结构。

switch-case执行效率是比if-else结果效率要稍微高一些。

帮我改善此页面

#流程控制 #if #else #条件 #switch #case

上次更新: 2020/12/18, 12:50:58

← Scanner类流程控制-循环结构→

流程控制-分支结构

# 前言

# 定义

# 流程结构

# 顺序结构

# 分支结构

# 循环结构

# if-else

# 语法格式

# 示例1

# 示例2

# 示例3

# 练习1

# 练习2

# 练习3

# 练习4

# 练习5

# 练习6

# 练习7

# 练习8

# 练习9

# 练习10

# swtich-case

# 语法格式

# 练习1

# 合并Case

# 练习2

# 练习3

# 练习4

# 练习5

# 小结

# `if-else`

# `swtich-case`