S03L04 - Java中的switch语句 - （第04部分）

html

精通 Java 中的 Switch Cases：全面指南
目录

介绍 ............................................................ 1
理解 Switch Cases ................. 3

基本 Switch 语句 ...................... 4
使用 Lambda 表达式的增强 Switch ................................................................. 6


在不同数据类型中使用 Switch .............................................................. 10

使用整数的 Switch .............................. 11
使用字符的 Switch ..................... 12
使用字符串的 Switch ............................... 13


Switch Cases 的最佳实践 ..... 16
结论 ............................................................ 19


介绍
Switch statements 是 Java 中基本的控制流结构，使开发人员能够根据表达式的值执行不同的代码部分。无论您是初学者进入 Java 编程领域，还是经验丰富的开发人员在完善您的技能，理解 switch cases 对于编写干净、高效和可维护的代码至关重要。
本电子书深入探讨了 Java 中 switch cases 的细微差别。我们将探索基本和增强的 switch statements，它们在各种数据类型中的应用，以及优化其使用的最佳实践。通过本指南的学习，您将掌握在 Java 项目中有效实现 switch cases 的知识。

理解 Switch Cases
Switch cases 提供了一种简化的方式，根据单个变量的值执行不同的操作。它们是多个 if-else 语句的替代方案，增强了代码的可读性和可维护性。
基本 Switch 语句
基本的 switch 语句会评估一个表达式并执行相应的 case 块。以下是一个简单的例子：




		
		
			
			
Java
			
			public class BasicSwitchExample {
    public static void main(String[] args) {
        int day = 3;
        String dayType;

        switch (day) {
            case 1:
                dayType = "Monday";
                break;
            case 2:
                dayType = "Tuesday";
                break;
            case 3:
                dayType = "Wednesday";
                break;
            default:
                dayType = "Invalid day";
                break;
        }

        System.out.println("Day: " + dayType);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
				
						public class BasicSwitchExample {
    public static void main(String[] args) {
        int day = 3;
        String dayType;
 
        switch (day) {
            case 1:
                dayType = "Monday";
                break;
            case 2:
                dayType = "Tuesday";
                break;
            case 3:
                dayType = "Wednesday";
                break;
            default:
                dayType = "Invalid day";
                break;
        }
 
        System.out.println("Day: " + dayType);
    }
}
					
				
			
		


解释：

Switch Expression: 在此示例中，switch expression 是整数 day。
Case Blocks: 每个 case 代表 day 的可能值。如果 day 匹配某个 case，则执行相应的代码块。
Break Statement: break 语句退出 switch，以防止继续执行下一个 case。
Default Case: 如果没有任何 case 与 switch expression 匹配，则执行 default case。

输出：




		
		
			
			
Java
			
			Day: Wednesday
			
				
					
				
					1
				
						Day: Wednesday
					
				
			
		


使用 Lambda 表达式的增强 Switch
Java 14 引入了 enhanced switch statements，允许使用 lambda expressions 更加简洁的语法。这种现代方法减少了样板代码并提高了可读性。




		
		
			
			
Java
			
			public class EnhancedSwitchExample {
    public static void main(String[] args) {
        int day = 3;
        String dayType = switch (day) {
            case 1 -> "Monday";
            case 2 -> "Tuesday";
            case 3 -> "Wednesday";
            default -> "Invalid day";
        };

        System.out.println("Day: " + dayType);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						public class EnhancedSwitchExample {
    public static void main(String[] args) {
        int day = 3;
        String dayType = switch (day) {
            case 1 -> "Monday";
            case 2 -> "Tuesday";
            case 3 -> "Wednesday";
            default -> "Invalid day";
        };
 
        System.out.println("Day: " + dayType);
    }
}
					
				
			
		


解释：

Arrow Syntax (->): 替换了冒号 (:)并消除了对 break 语句的需求。
Expression-Based: switch 可以直接返回一个值，并将其赋给 dayType。
Enhanced Readability: 代码更加简洁，易于阅读。

输出：




		
		
			
			
Java
			
			Day: Wednesday
			
				
					
				
					1
				
						Day: Wednesday
					
				
			
		


图示：增强 Switch 流程




		
		
			
			
Java
			
			flowchart TD
    A[Start] --> B[Evaluate Switch Expression]
    B --> C{Match Case?}
    C -->|Yes| D[Execute Corresponding Block]
    D --> E[Assign Value]
    E --> F[End]
    C -->|No| G[Execute Default Block]
    G --> F
			
				
					
				
					1
2
3
4
5
6
7
8
				
						flowchart TD
    A[Start] --> B[Evaluate Switch Expression]
    B --> C{Match Case?}
    C -->|Yes| D[Execute Corresponding Block]
    D --> E[Assign Value]
    E --> F[End]
    C -->|No| G[Execute Default Block]
    G --> F
					
				
			
		



在不同数据类型中使用 Switch
Java 中的 switch statements 多功能，可以在各种数据类型上操作。理解如何在不同类型中使用 switch 可以增强您处理多样化场景的能力。
使用整数的 Switch
使用整数进行 Switch 是直观的，且常用于数值控制流。




		
		
			
			
Java
			
			public class SwitchWithInteger {
    public static void main(String[] args) {
        int score = 85;
        String grade;

        switch (score / 10) {
            case 10:
            case 9:
                grade = "A";
                break;
            case 8:
                grade = "B";
                break;
            case 7:
                grade = "C";
                break;
            case 6:
                grade = "D";
                break;
            default:
                grade = "F";
                break;
        }

        System.out.println("Grade: " + grade);
    }
}
			
				
					
				
					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
				
						public class SwitchWithInteger {
    public static void main(String[] args) {
        int score = 85;
        String grade;
 
        switch (score / 10) {
            case 10:
            case 9:
                grade = "A";
                break;
            case 8:
                grade = "B";
                break;
            case 7:
                grade = "C";
                break;
            case 6:
                grade = "D";
                break;
            default:
                grade = "F";
                break;
        }
 
        System.out.println("Grade: " + grade);
    }
}
					
				
			
		


解释：

将 score 除以 10 以确定成绩范围。
多个 case 可以映射到同一个代码块（例如，10 和 9 都分配 A 级成绩）。

输出：




		
		
			
			
Java
			
			Grade: B
			
				
					
				
					1
				
						Grade: B
					
				
			
		


使用字符的 Switch
在 switch statements 中使用字符，可以基于单个字符进行精确控制。




		
		
			
			
Java
			
			public class SwitchWithCharacter {
    public static void main(String[] args) {
        char option = 'B';
        String optionDescription;

        switch (option) {
            case 'A':
                optionDescription = "Add";
                break;
            case 'B':
                optionDescription = "Delete";
                break;
            case 'C':
                optionDescription = "Update";
                break;
            default:
                optionDescription = "Invalid option";
                break;
        }

        System.out.println("Option Selected: " + optionDescription);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
				
						public class SwitchWithCharacter {
    public static void main(String[] args) {
        char option = 'B';
        String optionDescription;
 
        switch (option) {
            case 'A':
                optionDescription = "Add";
                break;
            case 'B':
                optionDescription = "Delete";
                break;
            case 'C':
                optionDescription = "Update";
                break;
            default:
                optionDescription = "Invalid option";
                break;
        }
 
        System.out.println("Option Selected: " + optionDescription);
    }
}
					
				
			
		


解释：

switch 语句评估字符 option，并执行匹配的 case。

输出：




		
		
			
			
Java
			
			Option Selected: Delete
			
				
					
				
					1
				
						Option Selected: Delete
					
				
			
		


使用字符串的 Switch
使用字符串进行 Switch 提供了处理文本数据的灵活性。建议使用像 toLowerCase() 或 toUpperCase() 这样的方法标准化字符串输入，以确保一致性。




		
		
			
			
Java
			
			public class SwitchWithString {
    public static void main(String[] args) {
        String command = "start";
        String action;

        switch (command.toLowerCase()) {
            case "start":
                action = "System is starting...";
                break;
            case "stop":
                action = "System is stopping...";
                break;
            case "restart":
                action = "System is restarting...";
                break;
            default:
                action = "Unknown command";
                break;
        }

        System.out.println(action);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
				
						public class SwitchWithString {
    public static void main(String[] args) {
        String command = "start";
        String action;
 
        switch (command.toLowerCase()) {
            case "start":
                action = "System is starting...";
                break;
            case "stop":
                action = "System is stopping...";
                break;
            case "restart":
                action = "System is restarting...";
                break;
            default:
                action = "Unknown command";
                break;
        }
 
        System.out.println(action);
    }
}
					
				
			
		


解释：

command 字符串被转换为小写，以确保不区分大小写的匹配。
每个 case 处理特定的命令。

输出：




		
		
			
			
Java
			
			System is starting...
			
				
					
				
					1
				
						System is starting...
					
				
			
		


比较表：使用不同数据类型的 Switch


数据类型
示例用法
优点


Integer
基于分数的评分系统
适用于数值范围，简单高效


Character
菜单选项选择
对单个字符输入进行精确控制


String
应用程序中的命令解释
处理文本数据灵活



Switch Cases 的最佳实践
为了充分利用 switch statements 的潜力并保持代码整洁，请遵循以下最佳实践：
1. 尽可能使用枚举（Enums）
Enums 提供了一种类型安全的方法来定义固定的常量集，增强了代码的清晰度并减少了错误。




		
		
			
			
Java
			
			enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

public class SwitchWithEnum {
    public static void main(String[] args) {
        Day today = Day.WEDNESDAY;
        String activity;

        switch (today) {
            case MONDAY:
            case FRIDAY:
                activity = "Work";
                break;
            case SATURDAY:
            case SUNDAY:
                activity = "Relax";
                break;
            default:
                activity = "Study";
                break;
        }

        System.out.println("Today's Activity: " + activity);
    }
}
			
				
					
				
					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
				
						enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}
 
public class SwitchWithEnum {
    public static void main(String[] args) {
        Day today = Day.WEDNESDAY;
        String activity;
 
        switch (today) {
            case MONDAY:
            case FRIDAY:
                activity = "Work";
                break;
            case SATURDAY:
            case SUNDAY:
                activity = "Relax";
                break;
            default:
                activity = "Study";
                break;
        }
 
        System.out.println("Today's Activity: " + activity);
    }
}
					
				
			
		


优点：

类型安全： 防止无效值。
可读性： Enums 使代码更易理解。

2. 避免不必要的 Fall-Through
Fall-through 发生在多个 case 执行相同的块而没有 break 语句。虽然它有用，但过度使用可能会导致意外的行为。




		
		
			
			
Java
			
			switch (option) {
    case 'A':
        // Perform action A
        break;
    case 'B':
        // Perform action B
        break;
    default:
        // Default action
        break;
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
				
						switch (option) {
    case 'A':
        // Perform action A
        break;
    case 'B':
        // Perform action B
        break;
    default:
        // Default action
        break;
}
					
				
			
		


建议： 明智地使用 fall-through，并注释您的意图以保持代码的清晰。
3. 优先使用增强 Switch 语句以简洁化代码
增强的 switch statements 减少了样板代码并提高了可读性。




		
		
			
			
Java
			
			String dayType = switch (day) {
    case MONDAY, FRIDAY -> "Workday";
    case SATURDAY, SUNDAY -> "Weekend";
    default -> "Study Day";
};
			
				
					
				
					1
2
3
4
5
				
						String dayType = switch (day) {
    case MONDAY, FRIDAY -> "Workday";
    case SATURDAY, SUNDAY -> "Weekend";
    default -> "Study Day";
};
					
				
			
		


4. 处理所有可能的 case
确保覆盖所有可能的值，特别是使用 enums 时。这可以防止意外的行为。




		
		
			
			
Java
			
			switch (day) {
    case MONDAY:
    case FRIDAY:
        // ...
    // Other cases
    default:
        throw new IllegalArgumentException("Unexpected value: " + day);
}
			
				
					
				
					1
2
3
4
5
6
7
8
				
						switch (day) {
    case MONDAY:
    case FRIDAY:
        // ...
    // Other cases
    default:
        throw new IllegalArgumentException("Unexpected value: " + day);
}
					
				
			
		


5. 保持 case 简单和专注
每个 case 应该处理一个单一、明确定义的操作，以保持代码的可读性和简洁性。

结论
Switch cases 是 Java 中强大的工具，正确使用时，可以简化复杂的条件逻辑并增强代码的可读性。从处理不同的数据类型如 integers、characters 和 strings，到利用带有 lambda expressions 的增强 switch statements，精通 switch cases 使开发人员能够编写高效且可维护的代码。
关键要点：

多功能性： Switch statements 可以处理各种数据类型，为控制流提供灵活性。
增强 Switch： 现代的 switch 语法与 lambda expressions 提供了更简洁且可读性更高的方法。
最佳实践： 利用 enums，避免不必要的 fall-through，并确保全面的 case 处理，对于优化 switch 的使用至关重要。

采用这些范式以提升您的 Java 编程技能并构建稳健的应用程序。
注意：本文由 AI 生成。
数据类型	示例用法	优点
Integer	基于分数的评分系统	适用于数值范围，简单高效
Character	菜单选项选择	对单个字符输入进行精确控制
String	应用程序中的命令解释	处理文本数据灵活