java选择结构switch基础入门
Java switch-case语句使用指南
Java switch-case语句使用指南
在Java编程中，switch-case语句是一种用于选择多个代码块中的一种执行路
径的结构。
它通常用于替换复杂的多个if-else语句，让代码更加简洁和易于理解。
本文将详细介绍Java中switch-case语句的基本语法、用法和最佳实践。
基本语法
switch-case语句的基本语法如下所示：
switch (expression) {
case value1:
// 代码块1
break;
case value2:
// 代码块2
break;
...
default:
// 默认代码块
}
•expression是一个表达式，通常是一个整数、字符或枚举类型。
它的值将会被用来匹配各个case中的值。
•每个case关键字后面跟着一个常量值，如果expression的值与某个case中的常量值匹配，那么对应的代码块将被执行。
•每个case代码块的最后通常会有一个break语句，用来表示跳出switch-case结构。
•default关键字用来定义一个默认的代码块，当没有任何case匹配时，将执行default代码块。
使用示例
下面是一个简单的示例，演示了如何在Java中使用switch-case语句：
```java int day = 3; String dayName; switch(day) { case 1: dayName =。
java 写出2个条件选择语句、3个循环语句的基本结构
java 写出2个条件选择语句、3个循环语句的基本结构一、条件选择语句在Java中，条件选择语句主要包括if语句和switch语句。
它们都是根据给定的条件来执行特定的代码块，从而实现程序的分支控制。
1. if语句的基本结构if语句是最基本的条件选择语句，它的结构如下：```javaif (条件) {// 如果条件为真，执行这里的代码} else {// 如果条件为假，执行这里的代码}```在这里，条件可以是一个布尔表达式，如果条件为真，则执行if语句块中的代码，否则执行else语句块中的代码。
2. switch语句的基本结构switch语句适用于多个条件的选择，它的基本结构如下：```javaswitch (表达式) {case 值1:// 如果表达式的值等于值1，执行这里的代码break;case 值2:// 如果表达式的值等于值2，执行这里的代码break;default:// 如果表达式的值都不满足以上条件，执行这里的代码break;}```在这里，表达式的值将会与每个case的值进行比较，如果匹配，则执行相应的代码块，如果没有匹配的值，则执行default语句块中的代码。
二、循环语句循环语句在Java中包括while循环、do-while循环和for循环，它们都用于多次执行特定的代码块。
1. while循环的基本结构while循环是最基本的循环语句，在每次循环开始时检查条件，然后执行循环体中的代码块，直到条件为假才会退出循环。
```javawhile (条件) {// 当条件为真时，执行这里的代码}```在这里，条件为真时，会一直执行循环体中的代码，直到条件为假才会停止循环。
2. do-while循环的基本结构do-while循环与while循环类似，但它保证循环体中的代码至少会执行一次，然后再检查条件是否为真。
```javado {// 执行这里的代码} while (条件);```在这里，循环体中的代码会先执行一次，然后再检查条件是否为真，如果为真则继续执行循环，否则退出循环。
java switch用法
执行过程：第1步：根据switch中表达式的值，依次匹配各个case。
如果表达式的值等于某个case中的常量值，则执行对应case中的执行语句。
第2步：执行完此case的执行语句以后，情况1：如果遇到break,则执行break并跳出当前的switch-case结构情况2：如果没有遇到break，则会继续执行当前case之后的其它case中的执行语句。
--->case 穿透...直到遇到break关键字或执行完所有的case及default的执行语句，跳出当前的switch-case结构使用注意点：switch(表达式)中表达式的值必须是下述几种类型之一：byte，short，char，int，枚举 (jdk 5.0)，String (jdk 7.0)；case子句中的值必须是常量，不能是变量名或不确定的表达式值或范围；同一个switch语句，所有case子句中的常量值互不相同；break语句用来在执行完一个case分支后使程序跳出switch语句块；如果没有break，程序会顺序执行到switch结尾；default子句是可选的。
同时，位置也是灵活的。
当没有匹配的case时，执行default语句。
应用举例案例1：public class SwitchCaseTest1 {public static void main(String args[]) {int num=1;switch(num){case0:System.out.println("zero");break;case1:System.out.println("one");break;case2:System.out.println("two");break;case3:System.out.println("three");break;default:System.out.println("other");//break;}}}案例2：public class SwitchCaseTest2 {public static void main(String args[]) {String season="summer";switch (season) {case"spring":System.out.println("春暖花开");break;case"summer":System.out.println("夏日炎炎");break;case"autumn":System.out.println("秋高气爽");break;case"winter":System.out.println("冬雪皑皑");break;default:System.out.println("季节输入有误");break;}}}错误举例：int key=10;switch(key){case key>0 :System.out.println("正数");break;case key<0:System.out.println("负数");break;default:System.out.println("零");break;}案例3：使用switch-case实现：对学生成绩大于60分的，输出“合格”。
java选择结构语句
java选择结构语句在Java中，选择结构语句可以根据条件来决定程序的执行路径。
Java中的选择结构语句包括if语句、switch语句和三元运算符(?:)。
1. if语句if语句是最常用的选择结构语句之一，它可以根据条件判断来执行不同的代码块。
if语句的基本语法如下：if(条件表达式){//条件为真时执行的代码块}如果条件表达式的结果为真，则会执行if语句后面的代码块；否则，程序会跳过if语句。
在if语句中，我们可以使用else关键字来表示条件为假时执行的代码块。
else语句的基本语法如下：if(条件表达式){//条件为真时执行的代码块}else{//条件为假时执行的代码块}2. switch语句switch语句可以根据不同的条件来执行不同的代码块。
switch 语句的基本语法如下：switch(表达式){case 值1://执行代码块1break;case 值2://执行代码块2break;...default://执行代码块n}在switch语句中，表达式的值会和各个case语句中的值进行匹配，如果匹配成功，则会执行对应的代码块；否则，程序会执行default语句中的代码块。
需要注意的是，在每个case语句中，必须使用break语句来跳出switch语句，否则程序会继续执行下一个case语句。
3. 三元运算符(?:)三元运算符也是一种常用的选择结构语句，它可以根据条件来返回不同的值。
三元运算符的基本语法如下：表达式1 ? 表达式2 : 表达式3如果表达式1的结果为真，则返回表达式2的值；否则，返回表达式3的值。
需要注意的是，在使用三元运算符时，表达式2和表达式3的类型必须相同，否则会产生类型转换的问题。
总结选择结构语句是Java语言中非常重要的控制结构之一，它可以根据不同的条件来执行不同的代码块。
if语句、switch语句和三元运算符是Java中常用的选择结构语句，它们在实际编程中都有着广泛的应用。
javaswitch结构
javaswitch结构在Java中，并没有像C语言中的switch结构那样的语法，但是Java提供了类似的功能，使用switch语句可以实现多分支的条件判断。
switch语句用于根据表达式的值选择要执行的代码块。
下面我会从多个角度来解释Java中的switch结构。
语法结构：java.switch (表达式) {。
case 值1:// 当表达式的值等于值1时执行的代码。
break;case 值2:// 当表达式的值等于值2时执行的代码。
break;// 可以有多个case.default:// 当表达式的值与所有case都不匹配时执行的代码。
}。
在这个语法结构中，首先会对表达式的值进行判断，然后根据不同的值执行相应的代码块。
如果表达式的值与任何一个case的值匹配，那么从匹配的case开始执行代码，直到遇到break语句或者switch语句结束。
如果没有任何一个case的值与表达式的值匹配，那么会执行default块中的代码。
需要注意的是，在每个case的代码块末尾通常会有一个break语句，这是为了在执行完相应的代码后跳出switch语句，如果没有break语句，那么会继续执行后面的case代码块，直到遇到break语句或者switch语句结束。
switch语句适用的情况：当有多个条件需要判断时，可以使用switch语句来使代码更加清晰和易读。
当每个条件需要执行的代码块较长时，使用switch语句可以减少重复的判断过程。
需要注意的是，switch语句中的表达式可以是整型、字符型、枚举类型或者字符串类型，但是不能是浮点型。
另外，case后面的值必须是常量，不能是变量。
总结来说，switch语句是Java中用于多分支条件判断的一种语法结构，能够根据表达式的值选择要执行的代码块，使代码更加清晰和易读。
【JAVASE基础篇】12.选择结构内容
【JAVASE基础篇】12.选择结构内容选择结构分为四种：if单选择结构、if-else双选择结构、if-else if-else多选择结构、switch结构1、if单选择结构格式：if(【布尔表达式】或者【true/false】){【语句块】}表⽰的意思是：如果布尔表达式结果是true或者直接就是true，则执⾏⼤括号内语句块，再执⾏⼤括号后⾯的语句如果布尔表达式结果是false或者直接就是false，直接跳过⼤括号内语句块，此if单选结构失效，执⾏⼤括号后⾯语句例：if(3<2){System.out.println("3<2真的");//不输出}System.out.println("3<2假的");//输出if后的⼤括号可以不写，如果不写只作⽤于第⼀个语句，分号结束。
但是⽆论如何都必须写，加强阅读性。
2、if-else双选择结构格式：if(【布尔表达式】或者【true/false】){【语句块1】}else{【语句块2】}表⽰的意思是：如果布尔表达式结果是true或者直接就是true，则执⾏语句块1，并且语句块2不执⾏，直接跳过语句块2，执⾏程序后⾯其他语句块如果布尔表达式结果是false或者直接就是false，直接跳语句块1，执⾏语句块2，再执⾏程序后⾯其他语句块例：int score=80;if(score>60){System.out.println("及格");//输出}else{System.out.println("不及格");//不输出}3、if-else if-else多选择结构格式：if(【布尔表达式1】或者【true/false】){【语句块1】}else if(【布尔表达式2】或者【true/false】){【语句块2】}.......else if(【布尔表达式n】或者【true/false】){【语句块n】}else{【语句块n+1】}当布尔表达式1为真，则执⾏语句块1并跳过剩下所有多选择结构语句，否则判断布尔表达式2，当布尔表达式2真时，则执⾏语句块2并跳过剩下所有多选择结构语句，以此类推。
29Java语言基础选择结构switch语句的格式及其解释
29Java语⾔基础选择结构switch语句的格式及其解释switch 语句的格式 inx = 10 switch(表达式){ case 值1; break; case 值2; break; ... defualt: 语句n-1; break; }注意 btye short char String 才能作为表达式long不⾏也就是基本类型⾥⾯能够转换为int的类型都可以做为case的表达式.1public class Test1_DataTypeConversion {23public static void main(String[] args) {4 String name = "张三";5 String gender = "男⼠";6switch (gender){7case "男⼠": //只能是常量不能是变量8 System.out.println("玩游戏");9break;10case "⼥⼠":11 System.out.println("化妆");12break;13default:14 System.out.println("你是⼈妖");15break;1617 }181920 }21222324 }注意⼀ break最后⼀个可以省略,其它不能省略⼆ default可以放在任意位置但是建议放在最后⾯1public class hello_world {23public static void main(String[] args) {45 Scanner sr = new Scanner(System.in);67int month = sr.nextInt();8switch(month){9case 1:10case 2:11case 3:12 System.out.println("⼀季度"); 13break;14case 4:15case 5;16case 6:17 System.out.println("⼆季度"); 18break;19202122 }2324 }2526 }。
java switch写法
java switch写法Java是一种广泛使用的编程语言，在Java中，switch语句是一种非常常见的控制语句。
它可以基于一个或多个条件来执行不同的语句块。
在本文中，我们将讨论Java中switch语句的写法。
1. 基本写法switch语句的基本写法如下：```switch (expression) {case value1:// statementsbreak;case value2:// statementsbreak;default:// statementsbreak;}```在这个语法中，expression表示要进行判断的表达式或值，value1、value2等是常量或值，并且每个case后面都有一个语句块和一个可选的break语句。
如果expression的值等于某个case的值，则执行该语句块，否则转到下一个case语句，如果没有找到匹配的case语句，则执行default语句块。
2. 每个case多个值在Java 7及以上版本中，我们可以使用一个case语句的多个值。
这种写法可以让代码更加简洁，例如：```switch (expression) {case value1:case value2:// statementsbreak;case value3:// statementsbreak;default:// statementsbreak;}```在这个示例中，如果expression的值为value1或value2，则执行第一个case的语句块；如果expression的值为value3，则执行第二个case的语句块；如果都不匹配，则执行default语句块。
3. 字符串类型的switch语句在Java 7及以上版本中，我们还可以使用字符串类型的switch 语句。
例如：```String str = "hello";switch (str) {case "hello":// statementsbreak;case "world":// statementsbreak;default:// statementsbreak;}```这种写法可以直接比较字符串，而不需要转换成其它类型。
java switch用法举例
主题：Java switch用法举例内容：1. 介绍Java中switch语句的基本用法在Java中，switch语句是一种用于在多个选项中进行选择的控制流语句。
它可以替代使用多个if-else语句的情况，能够使代码更加简洁清晰。
switch语句通常与case和default标签一起使用，以实现对不同情况的处理。
2. switch语句的语法结构switch语句的基本语法结构如下：```javaswitch (表达式) {case 值1:// 执行代码块1break;case 值2:// 执行代码块2break;// ...default:// 默认执行的代码块}```3. switch语句的使用示例下面通过几个具体的示例来演示switch语句的用法：```javaint choice = 2;String result = "";switch (choice) {case 1:result = "选择了1";break;case 2:result = "选择了2";break;case 3:result = "选择了3";break;default:result = "无效选择";}System.out.println(result);```在这个例子中，根据choice的值，程序会进入对应的case分支，执行相应的代码块，并在break语句处跳出switch语句。
4. 注意事项在使用switch语句时，需要注意以下几点：- switch语句中的表达式可以是整数、字符或字符串。
- case标签后的值必须是常量表达式，而且值的类型必须与表达式的类型相同。
- 每个case分支结束后都要使用break语句，以避免执行其他分支的代码块。
5. switch语句的性能及适用场景相比于使用多个if-else语句，switch语句可以提高代码的执行效率。
Java编程基础-选择和循环语句
Java编程基础-选择和循环语句⼀、选择结构语句选择结构：也被称为分⽀结构。
选择结构有特定的语法规则，代码要执⾏具体的逻辑运算进⾏判断，逻辑运算的结果有两个，所以产⽣选择，按照不同的选择执⾏不同的代码。
语⾔提供了两种选择结构语句：if语句和switch语句1、if语句if语句有三种语法格式。
(1)、if语句第⼀种语法格式(适合⼀种判断)if(条件表达式){语句体;}执⾏流程：判断条件表达式的结果，当为为true时,{}中的执⾏语句体才会执⾏,否则不执⾏语句体。
注意：条件表达式的结果必须是布尔类型；if如果控制的语句只有⼀条，可以不写中括号{},直接跟语句体，但如果跟多条语句，⼤括号不能省略，建议两种情况下都写。
代码⽰例演⽰：[java]//if语句第⼀种语法格式int i=6;if(i%2==0){System.out.println("if条件为true");}System.out.println("over");输出结果为：if条件为trueover(2)、if语句第⼆种语法格式(适合两种判断)if(条件表达式){语句体1;}else{语句体2;}执⾏流程：同样先判断条件表达式的结果，如果为true，则执⾏语句体1，为false则执⾏语句体2.代码⽰例演⽰：[java]//if语句第⼆种语法格式int j=-2;if(j>0){System.out.println(j+"为正数");}else{System.out.println(j+"为负数");}System.out.println("over");输出结果为：-2为负数over(3)、if语句第三种语法格式(适合多种判断)if(条件表达式1){语句体1;}else if(条件表达式2){语句体2;}......else if(条件表达式n){语句体n;}else{语句体n+1;}执⾏流程：⾸先判断条件表达式1的结果，如果为true，则执⾏语句体1，为false则继续判断条件表达式2的结果，如果为true，则执⾏语句体2，为false则继续判断下⼀个条件表达式的结果，以此类推，如果所有的判断条件都为false，则意味着所有的条件均未得到满⾜，则执⾏语句体n+1。
java switch的用法
java switch的用法Java是一种广泛使用的编程语言，它被广泛应用于各种领域，如Web开发、移动应用开发、游戏开发等。
Java中的switch语句是一种流程控制语句，它可以用于多个条件的判断。
在本文中，我们将探讨Java switch语句的用法。
1. switch语句的基本语法switch语句包含一个表达式和多个case分支。
表达式的值将被与每个case分支的值进行比较。
如果表达式的值与某个case分支的值相等，则执行该分支。
如果没有一个分支与表达式的值相等，则执行default分支（如果存在的话）。
switch语句的基本语法如下：``` switch (表达式) { case 值 1: //执行代码块1 break; case 值 2:// 执行代码块2 break; case 值 3:// 执行代码块3 break; … default: // 默认执行的代码块 } ```关键字switch后面的括号中应该是一个值类型的表达式，可以是任何可比较的数据类型，如整数、字符、枚举等。
每个case分支应该包含一个常量或者字面量。
break语句用于结束当前分支的执行，并跳出switch语句的执行。
2. switch语句的执行流程当执行一个switch语句时，表达式的值将被与每个case分支的值进行比较。
如果表达式的值与某个case分支的值相等，则执行该分支，并终止switch语句的执行。
如果没有一个分支与表达式的值相等，则执行default分支（如果存在的话）。
switch语句的执行流程如下：1. 评估表达式的值；2. 将表达式的值与case分支的值进行比较；3. 如果有一个分支的值与表达式的值相等，则执行该分支的语句；4. 如果没有一个分支的值与表达式的值相等，则执行default分支的语句（如果存在的话）；5. switch语句执行完毕。
在switch语句中，如果没有break语句终止当前分支的执行，则程序将执行下一个分支的语句，直到遇到break 语句或者程序执行完毕。
Java中的switch选择结构
Java中的switch选择结构
为什么需要使⽤switch选择结构
先来看⼀下这个案例：
张三参加计算机编程⼤赛
如果获得第⼀名，奖励10000元的奖学⾦
如果获得第⼆名，奖励5000元的奖学⾦
如果获得第三名，奖励2000元的奖学⾦
否则，不给任何奖励
从题⽬要求来看⾸先会想到可以使⽤if选择结构来判断，但代码结构上看显得代码冗余，结构复杂。
有多次的等值判断。
为了解决上述问题，我们可以引⽤switch的选择结构。
先了解⼀下switch选择结构的语法和结构：
switch选择结构中存在case，break，default⼏个关键字；
switch选择结构都是⽤来处理多分⽀条件，但只能⽤来处理等值条件判断的情况的结构；
再回头看看上⾯那个案例我们⽤switch来把他写出来：
public static void main(String[] args) {
int mc = 1;
switch (mc) {
case 1:
System.out.println("奖励10000元的奖学⾦");
break;
case 2:
System.out.println("奖励5000元的奖学⾦");
break;
case 3:
System.out.println("奖励2000元的奖学⾦"); break;
default:
System.out.println("继续努⼒明年再来");
break;
}
}
}。
switch case语句的用法java
Java 中的 `switch` 语句是一种多分支选择结构，它可以根据一个表达式的值选择执行不同的代码块。
`switch` 语句中的每个代码块都由一个 `case` 标签来标识，这个标签后面跟着一个值和一个冒号。
如果表达式的值与某个 `case` 标签的值相匹配，那么就会执行该标签后面的代码。
下面是 `switch` 语句的基本用法：```javaint number = ...; // 这里是要检查的变量switch (number) {case 1:// 当 number 等于 1 时执行的代码System.out.println("Number is 1");break; // 结束 switch 语句case 2:// 当 number 等于 2 时执行的代码System.out.println("Number is 2");break; // 结束 switch 语句// 可以有更多的 case 分支default:// 当没有任何其他 case 匹配时执行的代码System.out.println("Number is neither 1 nor 2");break; // 通常在 default 分支的最后也会有一个 break}```在上面的例子中，`switch` 语句检查 `number` 变量的值。
如果 `number` 等于 1，就执行第一个 `case` 分支的代码；如果等于 2，就执行第二个 `case` 分支的代码；如果`number` 既不等于 1 也不等于 2，就执行 `default` 分支的代码。
注意几个重要的点：- 每个 `case` 后面的代码通常都会以 `break` 语句结束，这样可以防止代码继续执行到下一个 `case` 分支（这种行为称为“穿透”）。
- `default` 分支是可选的，但如果存在，它通常位于 `switch` 语句的最后。
java中switch语句用法
java中switch语句用法在Java中，switch语句是一种用于根据不同条件执行不同代码块的控制流语句。
它是替代多个if-else语句的一种更简洁的方式。
switch语句的基本语法如下：```switch (表达式) {case 值1:// 执行代码块1break;case 值2:// 执行代码块2break;case 值3:// 执行代码块3break;...default:// 执行默认代码块}```在switch语句中，表达式的值会与每个case后面的值进行比较。
如果匹配成功，则执行相应的代码块。
如果没有匹配成功，可以在最后使用default关键字来执行默认的代码块。
需要注意的是，每个case后面的值必须是一个常量表达式，而且不能重复。
而且在每个case代码块的末尾，需要使用break关键字来结束整个switch语句，否则会继续执行下一个case代码块，直到遇到break或者整个switch语句结束。
除了使用常量表达式作为case的值之外，Java 7开始还支持使用字符串作为case的值。
例如：```String fruit = 'apple';switch (fruit) {case 'apple':System.out.println('This is an apple');break;case 'banana':System.out.println('This is a banana');break;}```在Java 12中，还引入了一种新的语法形式，使用箭头(->)代替case和break 关键字，使得代码更加简洁。
例如：```String fruit = 'apple';switch (fruit) {case 'apple' -> System.out.println('This is an apple');case 'banana' -> System.out.println('This is a banana');}```总结来说，switch语句是一种用于根据不同条件执行不同代码块的控制流语句。
Java选择结构（if、switch）
Java选择结构（if、switch）我们有时会⾯临⼈⽣的分岔路⼝，⽣活中也会有许多⼤⼤⼩⼩的选择。
程序也是为了提⾼⼈们⽣活质量的，不可能脱离实际⽣活，所以Java程序中也必须得实现选择结构。
当我们的代码按照书写顺序⼀句⼀句执⾏的时候，此时则为顺序结构。
像我们书写的多条输出语句，会⼀句⼀句从上到下的按照顺序执⾏。
选择结构是在具备某种条件下就做什么选择，在我们⽣活中也频繁使⽤：如果我考了100分，我妈妈就会给我奖励；如果今天不下⾬，我就去公园玩......没错，Java就是使⽤如果，即if1.if单if语句语法：if（条件：布尔类型的数据，可以是表达式，也可以⽤逻辑运算符）{ //如果条件为 true，执⾏语句 }；注意：if(a!=0)和if(a)是等价的流程图：如果我考试考了100分，那么妈妈就会给我奖励⼀个玩具package com.dh.control;public class IfDemo01 {public static void main(String[] args) {//ifint score = 100;if(score == 100){System.out.println("太棒啦！奖励⼀个⼩汽车！");}}}if...else语句语法：：if（条件表达式）{ //满⾜条件执⾏的语句 } else { //不满⾜条件的执⾏语句 } ;流程图：如果我考试考了100分，那么妈妈就会给我奖励⼀个玩具，否则，就没有奖励了package com.dh.control;public class IfDemo01 {public static void main(String[] args) {//if...elseint score = 99;if(score == 100){System.out.println("太棒啦！奖励⼀个⼩汽车！");}else{System.out.println("很遗憾，下次再接再厉！");}}}if...else if...else(else可选)语法：if（条件表达式）{ //满⾜条件 1 的执⾏语句 } else if（条件表达式）{ //可以有多个 else if 块 //满⾜条件 2 的执⾏语句 } else { //不满⾜条件的执⾏语句 } ;流程图：99分都没有奖励的话，就太让⼈沮丧了，和妈妈重新商量了⼀下，妈妈承诺，如果我考试考了100分，给我奖励⼀个玩具，如果我考了90分以上，就给我奖励⼀个冰淇淋，否则，就没有奖励了package com.dh.control;public class IfDemo01 {public static void main(String[] args) {int score = 99;if(score == 100){System.out.println("太棒啦！奖励⼀个⼩汽车！");}else if(score>=90){System.out.println("⼲的不错！奖励⼀个冰淇淋");} else{System.out.println("很遗憾，下次再接再厉！");}}}注意：选择结构：判断条件，符合条件则返回结果，不再进⾏之后的条件判断，如果不符合条件，即继续判断条件，直到所有判断条件都不满⾜时最后⼀个为结果。
switch语句基本结构java
在Java中，switch语句的基本结构如下：
java
switch (expression) {
case value1:
// 代码块1
break;
case value2:
// 代码块2
break;
case value3:
// 代码块3
break;
...
default:
// 默认代码块
break;
}
在上面的代码中，expression表示要进行比较的表达式，可以是任何基本数据类型、枚举类型、字符串类型等。
value1、value2、value3等是表达式可能的取值。
每个case后面的代码块中可以包含一系列要执行的语句。
当expression的值与某个case的值相同时，与该case关联的代码块将被执行。
如果没有任何一个case的值与expression的值相等，那么执行default代码块中的代码。
请注意，在每个case后面必须使用break语句来终止当前的case，并跳出switch语句。
如果省略了break语句，程序将继续执行下一个case的代码块，直到遇到break语句或整个switch语句结束为止。
这种行为被称为“case穿透”。
Java基础04--选择结构(switch)
break;
} 演示示例3：使用switch常见问题
12/26
比较switch和多重if选择结构
相同点
都是用来处理多分支条件的结构
不同点
switch选择结构
只能处理等值条件判断的情况，而且条件必须是整型 变量或字符型变量
多重if选择结构
没有switch选择结构的限制，特别适合某个变量处于 某个连续区间时的情况
5/26
为什么使用switch选择结构
问题
韩嫣参加计算机编程大赛
如果获得第一名，将参加麻省理工大学组织的1个月夏令营 如果获得第二名，将奖励惠普笔记本电脑一部 如果获得第三名，将奖励移动硬盘一个 否则，不给任何奖励
解决方法：
使用多重if选择结构实现 使用switch选择结构解决
缺点：结构复杂，啰嗦 特点：条件为等值判断
switch选择结构
多重分支并且条件判断是等值判断的情况
18/26
为什么要处理系统异常
问题
菜单跳转的程序，如果用户错误地输入了一个 不允许的字符，例如“s”，程序会怎样呢？
分析
为了使程序更加健壮，程序员在编码时要考虑用户可能 出现的任何问题，并且在程序中做出相应的判断，给用 户一个友好的提示
Scanner对象的hasNextInt()方法，可以判断用户 从键盘输入的字符是否是合法的数字
常见错误4-1
代码阅读
int mingCi = 1; switch (mingCi){ case 1: case 2: System.out.println("奖励惠普笔记本电脑一部"); case 3: 输出结果是什么？
System.out.println("参加麻省理工大学组织的1个月夏令营");
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
1:switch语句(掌握)(1)格式：switch(表达式) {case 值1:语句体1;break;case 值2:语句体2;break;...default:语句体n+1;break;}格式解释说明：switch:说明这是switch语句。
表达式:可以是byte,short,int,charJDK5以后可以是枚举JDK7以后可以是字符串case:后面的值就是要和表达式进行比较的值break:表示程序到这里中断，跳出switch语句default:如果所有的情况都不匹配,就执行这里,相当于if语句中的else(2)面试题switch语句的表达式可以是byte吗?可以是long吗?可以是String吗?可以,不可以,JDK7以后可以(3)执行流程:A:首先计算表达式的值B:和每一个case进行匹配，如果有就执行对应的语句体，看到break 就结束。
C:如果没有匹配，就执行default的语句体n+1。
(4)注意事项:A:case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的B:default可以省略吗?可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。
特殊情况：case就可以把值固定。
A,B,C,DC:break可以省略吗?可以省略，但是结果可能不是我们想要的。
会出现一个现象：case穿透。
最终我们建议不要省略D:default一定要在最后吗?不是，可以在任意位置。
但是建议在最后。
E:switch语句的结束条件a:遇到break就结束了b:执行到末尾就结束了(5)案例：A:键盘录入一个数字(1-7),输出对应的星期几。
B:单项选择题C:键盘录入一个字符串的问题String s = sc.nextLine();D:根据给定的月份,输出对应的季节(6)if语句和switch语句各自的场景A:if针对boolean类型的判断针对一个范围的判断针对几个常量的判断B:switch针对几个常量的判断2:循环语句(掌握)(1)有三种:for,while,do...while(2)for循环语句A:格式for(初始化语句;判断条件语句;控制条件语句){循环体语句;}执行流程：a:执行初始化语句b:执行判断条件语句如果这里是true，就继续如果这里是false，循环就结束c:执行循环体语句d:执行控制条件语句e:回到bB:注意事项a:判断条件语句无论简单还是复杂，结果是boolean类型b:循环体语句如果是一条，可以省略大括号，但是不建议c:有分号就没有左大括号，有左大括号就没有分号C:案例a:输出10次HelloWorldb:输出1-10的数据c:输出10-1的数据d:求1-10的和e:求1-100的和,求1-100的偶数和,求1-100的奇数和f:求5的阶乘g:在控制台打印水仙花数h:统计水仙花个数i:改进版的回文数一个五位数个位 = 万位十位 = 千位个位 + 十位 + 千位 + 万位 = 百位j:统计1-1000之间同时满足如下条件的数据有多少个x%3==2x%5==3x%7==2(3)while循环A:基本格式while(判断条件语句) {循环体语句;}扩展格式：初始化语句;while(判断条件语句){循环体语句;控制条件语句;}通过查看这个格式，我们就知道while循环可以和for循环等价转换。
B:while的练习把for语句的练习用while改进C:for和while的区别a:使用上的区别for语句的那个控制条件变量,在循环结束后不能在使用了。
而while的可以继续使用。
b:理解上的区别for适合于一个范围的判断while适合次数不明确的举例:吃葡萄D:案例：a:珠穆朗玛峰问题b:小芳存钱问题(break以后才能做)(4)do...while循环A:基本格式do {循环体语句;}while(判断条件语句);扩展格式：初始化语句;do {循环体语句;控制条件语句;}while(判断条件语句);通过查看格式，我们就可以看出其实三种循环的格式可以是统一的。
B:三种循环的区别a:do...while循环至少执行一次循环体b:for和while必须先判断条件是否是true，然后后才能决定是否执行循环体(5)循环使用的注意事项(死循环)A:一定要注意修改控制条件,否则容易出现死循环。
B:最简单的死循环格式a:while(true){...}b:for(;;){}3:控制跳转语句(掌握)(1)break:中断的意思A:用在循环和switch语句中，离开此应用场景无意义。
B:作用a:跳出单层循环b:跳出多层循环，需要标签语句的配合(2)continue:继续A:用在循环中，离开此应用场景无意义。
B:作用a:跳出单层循环的一次，可以继续下一次C:填空题for(int x=1; x<=10; x++) {if(x%3 == 0) {//补齐代码}System.out.println("Java基础班");}如何让控制台输出2次：Java基础班如何让控制台输出7次：Java基础班如何让控制台输出13次：Java基础班(3)return:返回A:用于结束方法的，后面还会在继续讲解和使用。
B:一旦遇到return,程序就不会在继续往后执行。
1 switch语句/*switch语句格式：switch(表达式) {case 值1:语句体1;break;case 值2:语句体2;break;...default:语句体n+1;break;}格式的解释：switch:表示这是switch选择结构表达式:这个地方的取值是有限定的byte,short,int,charJDK5以后可以是枚举JDK7以后可以是字符串case:后面跟的是要和表达式进行比较的值语句体:要执行的代码break:表示中断，结束的意思，可以控制switch语句的结束。
default:当所有的值都和表达式不匹配的时候，就执行default控制的语句。
其实它就相当于if语句的else。
面试题：byte可以作为switch的表达式吗?long可以作为switch的表达式吗?String可以作为switch的表达式吗?案例：键盘录入一个数据，根据这个数据，我们输出对应的星期?键盘录入1,对应输出星期一键盘录入2,对应输出星期二...键盘录入7,对应输出星期日分析：1:键盘录入，用Scanner实现2:判断我们既可以使用if语句，也可以使用我们要讲解的switch语句注意：A:遇到左大括号缩进一个tab的位置。
B:关联不是很大的语句间空行*/import java.util.Scanner;class SwitchDemo {public static void main(String[] args) {//创建键盘录入对象Scanner sc = new Scanner(System.in);//控制键盘录入数据System.out.println("请输入一个数据(1-7):");int week = sc.nextInt(); //3//switch判断语句switch(week) {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语句的注意事项：A:case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的B:default可以省略吗?可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。
特殊情况：case就可以把值固定。
A,B,C,DC:break可以省略吗?可以省略，但是结果可能不是我们想要的。
会出现一个现象：case穿透。
最终我们建议不要省略D:default一定要在最后吗?不是，可以在任意位置。
但是建议在最后。
E:switch语句的结束条件a:遇到break就结束了b:执行到末尾就结束了*/import java.util.Scanner;class SwitchDemo2 {public static void main(String[] args) {//创建键盘录入对象Scanner sc = new Scanner(System.in);//控制键盘录入数据System.out.println("请输入一个数据(1-7):");int week = sc.nextInt(); //3//定义常量//int number = 3;//然后把case后面的值改为number，就会报错//switch判断语句switch(week) {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;}}}/*看程序写结果*/class SwitchTest {public static void main(String[] args) {int x = 2;int y = 3;switch(x){default:y++;break;case 3:y++;case 4:y++;}System.out.println("y="+y);System.out.println("---------------");int a = 2;int b = 3;switch(a){default:b++;case 3:b++;case 4:b++;}System.out.println("b="+b);}}2 模拟单项选择题/*模拟单项选择题。