选择结构（switch语句）
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();
//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：表示这是switch选择结构
-
表达式：这个地方的取值是有限定的
byte,short,int,char
JDK5以后可以是枚举
JDK7以后可以是字符串
-
case：后跟的是要和表达式进行比较的值
-
语句体：要执行的代码
-
break： 表示中断、结束的意思，可以控制switch语句的结束
-
default：当所有的值都和表达式不匹配的时候，就执行default控制的语句。相当于if语句的else.
执行流程
-
先计算出表达式的值
-
其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
-
最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
switch语句的注意事项
-
case后面只能是常量，不能是变量，而且多个case后面的值不能出现相同的。
-
default可以省略吗？
可以省略，但不建议，因为它的作用是对不正确的情况给出提示，除非判断的值是固定的（单选题）。
-
break可以省略吗？
可以省略，但不一定能得到想要的结果，会出现case穿透的现象，不建议省略。
-
default可以放在任意位置吗？
可以，但建议在最后。
-
switch语句的结束条件
-
遇到break结束
-
执行到末尾结束
-
练习
根据键盘录入的字符串，判断是否有满足要求的
/*
根据键盘录入的字符串，判断是否有满足要求的，如果有就输出，否则提示有误。
String s = sc.nextLine();
*/
import java.util.Scanner;
class SwitchText3 {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
//录入数据
System.out.println("请输入你要判断的字符串：");
String s = sc.nextLine();
switch(s) {
case "hello":
System.out.println("你输入的是hello");
break;
case "world":
System.out.println("你输入的是world");
break;
case "java":
System.out.println("你输入的是java");
break;
default:
System.out.println("没有找到你输入的数据");
break;
}
}
}
if语句和switch语句的区别
-
if语句的使用场景
-
针对结果是boolean类型的判断
-
针对一个范围的判断
-
针对几个常量值的判断
-
-
switch语句的使用场景
-
针对几个常量值的判断
-
循环结构
循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复的代码被称为循环体语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。
循环语句的组成
-
初始化语句
一条或者多条语句，这些语句完成一些初始化操作。
-
判断条件语句
这是一个boolen表达式，这个表达式能决定是否执行循环体。
-
循环体语句
要做多次的事情。
-
控制条件语句
这个部分是在一次循环结束后，下一次循环判断条件执行前执行，通过用于控制循环条件中的变量，使得循环在合适的时候结束。
循环结构（for循环语句）
for循环语句格式
for(初始化语句;判断条件语句;控制条件语句) {
循环体语句;
}
执行流程
-
执行初始化语句
-
执行判断条件语句，false → 循环结束，true → 继续执行
-
执行循环体语句
-
执行控制条件语句
-
回到 2 继续
注意事项
-
判断条件语句的结果是一个boolean类型。
-
循环体语句如果是一条，大括号可以省略，循环体语句如果是多条，大括号不可以省略。建议永远不要省略。
-
一般来说，有左大括号就没有分号，有分号就没有左大括号。
案例
输出十次"HelloWorld"
/*
需求：请在控制台输出十次"HelloWorld"
*/
class ForDemo {
public static void main(String[] arge) {
for(int x=1; x<=10; x++) {
System.out.println("HelloWorld");
}
}
}
1-10求和
/*
需求：求出1-10之间数据之和
分析：
0+1=1
1+2=3
3+3=6
6+4=10
10+5=15
...
由此可见我们要定义两个变量：
一个变量用于存储第一个加数，第一个加数保存的是以前的所有数据和，默认初始化值应该是0.
一个变量用于存储第二个加数，第二个加数就是每次数据变化的值。
--求和思想--
*/
class ForDemo3 {
public static void main(String [] args) {
//定义第一个加数
int sum = 0;
for(int x=1 ;x<=10; x++) {
//这里的x其实是第二个加数
sum += x;
}
System.out.println("sum:"+sum);
}
}
1-100求偶数和
/*
需求：求出1-100之间偶数和（奇数和同理）
*/
class ForDemo4 {
public static void main(String[] args){
//方式1
int sum = 0;
for(int x=1; x<=100; x++) {
if(x%2 == 0) {
sum += x;
}
}
System.out.println("sum:"+sum);
//方式2
int sum1 = 0;
for(int x=0; x<=100; x+=2) {
sum1 += x;
}
System.out.println("sum1:"+sum1);
}
}
求5的阶乘
/*
需求：求5的阶乘
--求阶乘思想--
*/
class ForDemo5 {
public static void main(String[] args) {
//定义最终结果变量
int jc = 1;
for(int x=1; x<=5; x++) {
jc *= x;
}
System.out.println("1-5的阶乘是："+jc);
}
}
输出所有"水仙花数"
/*
需求：在控制台输出所有的"水仙花数"
分析：
"水仙花数"：是指一个三位数，其各位数字的立方和等于该数本身。如：153（153 = 1*1*1 + 5*5*5 + 3*3*3）
A：三位数其实是告诉了我们范围。
B：通过for循环我们就可以实现获取每一个三位数，但是麻烦是如何获取这个三位数的个、十、百位上的数据。
如何获取一个数据的个、十、百位？
假设有一个数据：153
ge: 153%10 = 3
shi: 153/10%10 = 5
bai: 153/10/10%10 = 1
qian:x/10/10/10%10
wan:x/10/10/10/10%10
...
C：让ge*ge*ge+shi*shi*shi+bai*bai*bai和该数据比较，如果相同，就把该数据在控制台输出。
*/
class ForDemo6 {
public static void main(String[] args) {
//三位数告诉了我们范围
for(int x=100; x<1000; x++) {
int ge = x%10;
int shi = x/10%10;
int bai = x/10/10%10;
//让ge*ge*ge+shi*shi*shi+bai*bai*bai和该数据比较
if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)) {
//如果相同，就把该数据在控制台输出。
System.out.println(x);
}
}
}
}
输出满足如下条件的五位数
/*
需求：请在控制台输出满足如下条件的五位数
个位等于万位
十位等于千位
个位+十位+千位+万位=百位
分析：
A：五位数告诉了范围
B：分解每一个五位数的个、十、百、千、万位上的数据
C：按照要求进行判断即可
*/
class ForDemo7 {
public static void main(String[] args) {
//五位数告诉了范围
for(int x=10000; x<100000; x++) {
//分解每一个五位数的个、十、百、千、万位上的数据
int ge = x%10;
int shi = x/10%10;
int bai = x/100%10;
int qian = x/1000%10;
int wan = x/10000%10;
//按照要求进行判断即可
if(ge==wan && shi==qian && (ge+shi+qian+wan==bai)) {
System.out.println(x);
}
}
}
}
统计"水仙花数"个数
/*
需求：统计"水仙花数"有多少个
分析：
A：水仙花数指一个三位数，其各位数字的立方和等于该数本身
B：定义统计变量，初始化值为0
C：三位数告诉了范围，用for循环解决
D：获取每一个三位数的个、十、百的数据
E：按照要求判断
F：若满足要求就计数
--统计思想--
*/
class ForDemo8 {
public static void main(String[] args) {
//定义统计变量，初始化值为0
int count = 0;
for(int x=100; x<1000; x++) {
//将三位数拆开成个、十、百的数据
int ge = x%10;
int shi = x/10%10;
int bai = x/100%10;
//按要求判断
if((ge*ge*ge + shi*shi*shi + bai*bai*bai) == x) {
//满足要求就计数
count++;
}
}
System.out.println("水仙花数共有："+count+"个");
}
}
统计1-1000之间同时满足以下条件的数据
/*
需求：统计1-1000之间同时满足以下条件的数据有几个
对3整除余2
对5整除余3
对7整除余2
分析：
A：1-1000给了范围，用for循环解决
B：定义统计变量，初始化值为0
C：满足要求的进行计数
*/
class ForDemo9 {
public static void main(String[] args) {
//定义统计变量，初始化值为0
int count = 0;
for(int x=1; x<=1000; x++) {
//满足要求的进行计数
if(x%3==2 && x%5==3 && x%7==2) {
count++;
}
}
System.out.println("符合条件的数据有："+count+"个");
}
}
循环结构（while循环语句）
while循环语句格式
-
基本格式：
while(判断条件语句) {
循环体语句；
}
-
扩展格式：
初始化语句;
while(判断条件语句) {
循环体语句;
控制条件语句;
}
注意：for循环和while循环是可以互相转换的
初始化语句; while(判断条件语句) { 循环体语句; 控制条件语句; } for(初始化语句;判断条件语句;控制条件语句) { 循环体语句; }
案例
1-100求和
/*
需求：用while循环求出1-100之和
分析：
思路和for循环基本一致
*/
class WhileDemo2 {
public static void main(String[] args) {
//定义一个存储加和的变量
int sum = 0;
//用while语句实现加和思想
int x = 1;
while(x<=100) {
sum += x;
x++;
}
System.out.println(sum);
}
}
统计"水仙花数"的个数
/*
需求：统计"水仙花数"的个数
分析：
思路与for循环基本一致
*/
class WhileDemo3 {
public static void main(String[] args) {
//定义一个统计变量，初始值为0
int count = 0;
//已知为三位数，且各位数字的立方和等于该数本身，用while语句实现
int x = 100;
while(x<1000) {
//将三位数拆开成个、十、百位的数据
int ge = x%10;
int shi = x/10%10;
int bai = x/100%10;
//按照要求判断，若符合则计数
if((ge*ge*ge + shi*shi*shi + bai*bai*bai) == x) {
count++;
}
//注意x++应在while大括号内，而不是if大括号内
x++;
}
System.out.println("水仙花数的个数为："+count+"个");
}
}
循环结构（for循环和while循环的区别）
-
使用区别：
如果想在循环结束后，继续使用控制变量的那个变量，用while循环，否则用for循环。
若不知道则用for循环，因为变量及早的从内存中消失，可以提高内存的使用效率。
-
另一种场景的理解：
如果是一个范围的需求，用for循环(如1-100求和)。
如果不明确要做多少次，用while循环较为合适(如吃葡萄——有就吃，不数几个)。
/*
分别在for循环体和while循环体的外面输出控制变量，有什么不同的结果？
*/
class WhileDemo4 {
public static void main(String[] args) {
//for循环实现
for(int x=0; x<10; x++) {
System.out.println("HelloWorld");
}
//这里不能继续访问x，因为x包含在for语句的大括号中，for循环结束后，x已消失。
//System.out.println(x);
//while循环实现
int y = 0;
while(y<10) {
System.out.println("HelloWorld");
y++;
}
//这里的y可以继续访问，因为y包含在main方法的大括号中，while循环结束后，仍存在。
System.out.println(y);
}
}
练习
纸折几次厚度不低于珠穆朗玛峰
/*
需求：
我国最高山峰是珠穆朗玛峰高8848m，我现在有一张足够大的纸张，厚度为0.01m。
请问：我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度？
分析：--统计思想--
A：定义一个统计变量，默认值为0
B：峰高8848m为最终的厚度，纸厚0.01m为初始厚度
C：折叠一次的变化：厚度*2
D：只要每次变化的厚度没有超过峰高8848m，就折叠，统计变量++
E：输出统计变量
*/
class WhileDemo5 {
public static void main(String[] args) {
//定义一个统计变量，默认值为0
int count = 0;
//为了简单，我把0.01变为1，8848变为884800
int end = 884800;
int start = 1;
//因为不明确次数，故用while循环
while(start
循环结构（do...while循环语句）
do...while循环语句格式
-
基本格式：
do {
循环体语句;
}while(判断条件语句);
-
扩展格式：
初始化语句;
do {
循环体语句;
控制条件语句;
}while(判断条件语句);
练习
输出10次HelloWorld；1-100求和
class DoWhileDemo {
public static void main(String[] args) {
//在控制台输出10次HelloWorld
int x = 0;
do {
System.out.println("HelloWorld");
x++;
}while(x<10);//此处为0-9，故"="不成立
System.out.println("--------------------");
//1-100求和
int sum = 0;
int y = 1;
do {
sum += y;
y++;
}while(y<=100);//100要加到sum中，故"="成立
System.out.println("1-100的和为："+sum);
}
}
循环语句（区别及注意事项）
-
三种循环语句都可以完成一样的功能，可以等价转换，但还是有一点去别的：
-
do...while循环至少执行一次循环体。
-
for循环、while循环先判断条件是否成立，再确定是否执行循环体。
-
注意事项：
-
写程序优先考虑顺序：for → while → do...while
-
如下代码是死循环：
DOS中遇到死循环按ctrl + C可强行停止
/*
注意死循环：
A：一定不要忘记控制条件语句，否则容易死循环
B：两种最简单的死循环格式
while(true) {...}
for(;;) {...}
*/
class DoWhileDemo3 {
public static void main(String[] args) {
int x = 0;
while(x<10) {
System.out.println(x);
//x++; ↓ 忘记会导致死循环
}
System.out.println("--------------------");
// ↓ 判断条件语句永远成立
while(true) {
System.out.println("今天很高兴，学习了死循环")；
}
System.out.println("--------------------");
// ↓ 三个条件不一定都有，可能只有一部分
for(;;) {
System.out.println("今天很高兴，学习了死循环")；
}
}
}
循环嵌套的使用
输出4行5列的星星
/*
需求：请输出一个4行5列的星星(*)图案
结果：
*****
*****
*****
*****
分析：
A：考虑如何实现一次输出1个*
输出语句的另一种格式:
System.out.print(); ← 不换行
如：
System.out.print("*");
System.out.print("*");
输出结果为：**
B：如果要在一行上打出多个*，可以用循环实现，但是不会换行，可以用空的输出语句实现换行
C：以上代码复制4次能够满足需求，但如果多次出现同样的代码，说明程序写的不好，可以用循环嵌套改进
- 循环嵌套：循环语句的循环体本身是一个循环语句。
结论：
外循环控制行数
内循环控制列数
*/
class ForForDemo {
public static void mian(String[] args) {
for(int x=0; x<5; x++) {
System.out.print("*");
//但是这种无论输出多少个*都不会换行
}
System.out.print(); //通过空的输出语句实现换行
//上面的代码重复4次可以满足需求，但不够好，可以用循环嵌套改进
System.out.println("--------------------");
//用循环嵌套改进
for(int y=0; y<4; y++) {
for(int x=0; x<5; X++) {
System.out.print("*");
}
}
}
}
输出直角三角形星星
/*
需求：请输出如下图形
*
**
***
****
*****
*/
class ForForDemo2 {
public static void main(String[] args) {
//通过观察，这是一个行是5，列是变化的形状
//我们先打印出一个5行5列的形状
for(int x=0; x<5; x++) {
for(int y=0; y<5; y++) {
System.out.print("*");
}
System.out.println();
System.out.println("--------------------");
//实现了一个5行5列的形状，但需要的列数是变化的
//如何变化：
//第一行：1列 y=0,y<=0,y++
//第二行：2列 y=0,y<=1,y++
//第三行：3列 y=0,y<=2,y++
//第四行：4列 y=0,y<=3,y++
//第五行：5列 y=0,y<=4,y++
//外循环x的变化，恰好是x=0,1,2,3,4
//则最终版的程序如下
for(int x=0; x<5; x++) {
for(int y=0; y<=x; y++) {
System.out.print("*");
}
System.out.println();
}
}
}
输出九九乘法表
/*
需求：请输出九九乘法表
分析：
首先写出九九乘法表
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
...
1*9=9 2*9=18 3*9=27 4*9=28 ... 9*9=81
可以把九九乘法表看成如下形状
*
**
***
****
*****
******
*******
********
*********
注意：
'\x' x表任意，这种叫做转义字符
如：
'\t' tab键的位置
'\r' 回车
'\n' 换行
*/
class ForForDemo3 {
public static void main(String[] args) {
for(int x=0; x<9; x++) {
for(int y=0; y<=x; y++) {
System.out.print("*");
}
System.out.println();
}
System.out.println("--------------------");
//为了使用数据，从1开始
for(int x=1; x<=9; x++) {
for(int y=1; y<=x; y++) {
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}
}
}
控制跳转语句
控制跳转语句（break）
break的使用场景
-
在选择结构switch语句中
-
在循环语句中（加入了if判断的情况）
注意：离开使用场景的存在是没有意义的
break的作用
-
跳出单层循环
-
跳出多层循环
-
带标签的跳出
-
格式：标签名:循环语句
-
标签名要符合Java的命名规则
class BreakDemo {
public static void main(String[] args) {
//跳出单层循环
for(int x=0; x<10; x++) {
if(x == 2) {
break;
}
System.out.println("HelloWorld");
}
System.out.println("over");
//输出结果：
//HelloWorld
//HelloWorld
//over ← 不受break影响，break仅表示中断当前循环
System.out.println("--------------------");
//跳出多层循环
wc:for(int x=0; x<3; x++) {
nc:for(int y=0; y<4; y++) {
if(y == 2) {
break nc; //输出3行4列*
//break wc; 输出1行2列*
}
System.out.print("*");
}
System.out.println();
}
}
}
控制跳转语句（continue）
continue的使用场景
-
循环中
注意：离开使用场景的存在是没有意义的
continue的作用
-
单层循环对比break，区别如下
-
break 退出当前循环，不再执行
-
continue 退出本次循环，继续执行下一次循环
-
带标签的使用
class ContinueDemo {
public static void main(String[] args) {
for(int x=0; x<10; x++) {
if(x == 3) {
//break; 输出结果0,1,2
continue; //输出结果0,1,2,4,5,6,7,8,9
}
System.out.println(x);
}
System.out.println("-------------------");
//练习题
for(int x=1; x<=10; x++) {
if(x%3==0) {
break; //输出2次"Java"
//continue; 输出7次"Java"
//System.out.println("Java"); 输出13次"Java"
}
System.out.println("Java");
}
}
}
控制跳转语句（return）
-
return关键字不是为了跳转出循环体，更常用的功能是结束一个方法，也就是退出一个方法，跳转到上层调用的方法。这个在方法的使用那里会在详细的讲解。
-
演示案例
class ReturnDemo {
public static void main(String[] args) {
for(int x=0; x<10; x++) {
if(x == 2) {
System.out.println("退出");
//break; 输出0,1,退出,over
//continue; 输出0,1,退出,3,4,5,6,7,8,9,over
return; //输出0,1,退出 此处return退出的是main方法，故后面的代码也不再生效
}
System.out.println(x);
}
System.out.println("over");
}
}
循环语句结合break的练习
/*
需求：小芳的妈妈每天给她2.5元钱，她都会存起来，但是，每当这一天是存钱的第5天或者5的倍数的话，她都会花去6元钱，请问，经过多少天，小芳才可以存到100元钱。
分析：
A：小芳的妈妈每天给她2.5元
double dayMoney = 2.5;
B：她都会存起来
double daySum = 0;
C：从第一天开始存
int dayCount = 1;
D：经过多少天，小芳才可以存到100元钱
double result = 100; （int,double均可）
E：每当这一天是存钱的第5天或者5的倍数的话，她都会花去6元钱
说明要判断dayCount的值，如果被5整除，就减去6元
daySum -= 6;
由此还隐含了一个问题，如果不是5的倍数的天数的话，钱要累加
daySum += dayMoney;
F：因为不知道是多少天，所以用死循环，一旦超过100元就退出循环
--统计思想--
*/
class WhileDemo {
public static void main(String[] args) {
//每天要存的钱是2.5元
double dayMoney = 2.5;
//存钱的初始化值是0
double daySum = 0;
//从第一天开始存
int dayCount = 1;
//最终存储不小于100元就停止存储
int result = 100;
//因为不知道是多少天，所以用死循环，一旦超过100元就退出循环
while(true) {
//累加钱
daySum += dayMoney;
//判断，一旦超过100元就退出循环
if(daySum >= result) {
System.out.println("共用了"+dayCount+"天存储了100元");
break;
}
if(dayCount%5 == 0) {
//花去6元钱
daySum -= 6;
System.out.println("第"+dayCount+"天花了6元钱");
}
//天数变化
dayCount++;
}
}
}
总结
switch语句（掌握）
循环语句（掌握）