1:switch语句(掌握)
(1)格式：
switch(表达式) {
case 值1:
语句体1;
break;
case 值2:
语句体2;
break;
...
default:
语句体n+1;
break;
}
格式解释说明：
switch:说明这是switch语句。
表达式:可以是byte,short,int,char
JDK5以后可以是枚举
JDK7以后可以是字符串
case:后面的值就是要和表达式进行比较的值
break:表示程序到这里中断，跳出switch语句
default:如果所有的情况都不匹配,就执行这里,相当于if语句中的else
(2)面试题
switch语句的表达式可以是byte吗?可以是long吗?可以是String吗?
可以,不可以,JDK7以后可以
Demo.java
1 /* 2 switch语句格式： 3 switch(表达式) { 4 case 值1: 5 语句体1; 6 break; 7 case 值2: 8 语句体2; 9 break; 10 ... 11 default: 12 语句体n+1; 13 break; 14 } 15 16 格式的解释： 17 switch:表示这是switch选择结构 18 表达式:这个地方的取值是有限定的 19 byte,short,int,char 20 JDK5以后可以是枚举 21 JDK7以后可以是字符串 22 case:后面跟的是要和表达式进行比较的值 23 语句体:要执行的代码 24 break:表示中断，结束的意思，可以控制switch语句的结束。 25 default:当所有的值都和表达式不匹配的时候，就执行default控制的语句。其实它就相当于if语句的else。 26 27 面试题： 28 byte可以作为switch的表达式吗? 29 long可以作为switch的表达式吗? 30 String可以作为switch的表达式吗? 31 32 案例： 33 键盘录入一个数据，根据这个数据，我们输出对应的星期? 34 键盘录入1,对应输出星期一 35 键盘录入2,对应输出星期二 36 ... 37 键盘录入7,对应输出星期日 38 39 分析： 40 1:键盘录入，用Scanner实现 41 2:判断我们既可以使用if语句，也可以使用我们要讲解的switch语句 42 43 注意： 44 A:遇到左大括号缩进一个tab的位置。 45 B:关联不是很大的语句间空行 46 */ 47 import java.util.Scanner; 48 49 class SwitchDemo { 50 public static void main(String[] args) { 51 //创建键盘录入对象 52 Scanner sc = new Scanner(System.in); 53 54 //控制键盘录入数据 55 System.out.println("请输入一个数据(1-7):"); 56 int week = sc.nextInt(); //3 57 58 //switch判断语句 59 switch(week) { 60 case 1: 61 System.out.println("星期一"); 62 break; 63 case 2: 64 System.out.println("星期二"); 65 break; 66 case 3: 67 System.out.println("星期三"); 68 break; 69 case 4: 70 System.out.println("星期四"); 71 break; 72 case 5: 73 System.out.println("星期五"); 74 break; 75 case 6: 76 System.out.println("星期六"); 77 break; 78 case 7: 79 System.out.println("星期日"); 80 break; 81 default: 82 System.out.println("你输入的数据有误"); 83 break; 84 } 85 } 86 }
(3)执行流程:
A:首先计算表达式的值
B:和每一个case进行匹配，如果有就执行对应的语句体，看到break就结束。
C:如果没有匹配，就执行default的语句体n+1。
(4)注意事项:
A:case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的
B:default可以省略吗?
可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。
特殊情况：
case就可以把值固定。
A,B,C,D
C: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
针对几个常量的判断
Demo1.java【int型常量】
1 /* 2 switch语句的注意事项： 3 A:case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的 4 B:default可以省略吗? 5 可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。 6 特殊情况： 7 case就可以把值固定。 8 A,B,C,D 9 C:break可以省略吗? 10 可以省略，但是结果可能不是我们想要的。 11 会出现一个现象：case穿透。 12 最终我们建议不要省略 13 D:default一定要在最后吗? 14 不是，可以在任意位置。但是建议在最后。 15 E:switch语句的结束条件 16 a:遇到break就结束了 17 b:执行到末尾就结束了 18 */ 19 import java.util.Scanner; 20 21 class SwitchDemo2 { 22 public static void main(String[] args) { 23 //创建键盘录入对象 24 Scanner sc = new Scanner(System.in); 25 26 //控制键盘录入数据 27 System.out.println("请输入一个数据(1-7):"); 28 int week = sc.nextInt(); //3 29 30 //定义常量 31 //int number = 3; 32 //然后把case后面的值改为number，就会报错 33 34 //switch判断语句 35 switch(week) { 36 case 1: 37 System.out.println("星期一"); 38 break; 39 case 2: 40 System.out.println("星期二"); 41 break; 42 case 3: 43 System.out.println("星期三"); 44 break; 45 case 4: 46 System.out.println("星期四"); 47 break; 48 case 5: 49 System.out.println("星期五"); 50 break; 51 case 6: 52 System.out.println("星期六"); 53 break; 54 case 7: 55 System.out.println("星期日"); 56 break; 57 default: 58 System.out.println("你输入的数据有误"); 59 //break; 60 } 61 } 62 }
Test.java【】
1 /* 2 看程序写结果 3 */ 4 class SwitchTest { 5 public static void main(String[] args) { 6 int x = 2; 7 int y = 3; 8 switch(x){ 9 default: 10 y++; 11 break; 12 case 3: 13 y++; 14 case 4: 15 y++; 16 } 17 System.out.println("y="+y); 18 System.out.println("---------------"); 19 20 int a = 2; 21 int b = 3; 22 switch(a){ 23 default: 24 b++; 25 case 3: 26 b++; 27 case 4: 28 b++; 29 } 30 System.out.println("b="+b); 31 } 32 }
SwitchTest2.java【char类型】
1 /* 2 模拟单项选择题。 3 4 分析： 5 A:出一个选择题，然后供你选择。 6 B:键盘录入选择的数据。 7 C:根据选择来给出你选择的结论。 8 */ 9 import java.util.Scanner; 10 11 class SwitchTest2 { 12 public static void main(String[] args) { 13 //出一个选择题，然后供你选择。 14 //由于我们现在没有办法键盘录入得到一个'A','B' 15 //这样的东西，我就用65，66这样的值替代 16 //将来我们获取到这样的值以后，强制转换为字符类型 17 System.out.println("下面的几个人你最爱谁?"); 18 System.out.println("65 林青霞"); 19 System.out.println("66 张曼玉"); 20 System.out.println("67 刘德华"); 21 System.out.println("68 王力宏"); 22 23 //键盘录入选择的数据。 24 Scanner sc = new Scanner(System.in); 25 26 System.out.println("请输入你的选择："); 27 int choiceNumber = sc.nextInt(); 28 29 //强制转换为字符类型 30 char choice = (char) choiceNumber; 31 32 switch(choice) { 33 case 'A': 34 System.out.println("恭喜你,选择正确"); 35 break; 36 case 'B': 37 System.out.println("不好意思，你选择有误"); 38 break; 39 case 'C': 40 System.out.println("不好意思，你选择有误"); 41 break; 42 case 'D': 43 System.out.println("不好意思，你选择有误"); 44 break; 45 default: 46 System.out.println("没有该选项"); 47 break; 48 } 49 } 50 }
SwitchTest3.java【String类型】
1 /* 2 根据你键盘录入的字符串，判断是否有满足要求的，如果有就输出。 3 否则，提示有误。 4 5 String s = sc.nextLine(); 6 */ 7 import java.util.Scanner; 8 9 class SwitchTest3 { 10 public static void main(String[] args) { 11 //创建键盘录入对象 12 Scanner sc = new Scanner(System.in); 13 14 //录入数据 15 System.out.println("请输入你要判断的字符串："); 16 String s = sc.nextLine(); 17 18 switch(s) { 19 case "hello": 20 System.out.println("你输入的是hello"); 21 break; 22 case "world": 23 System.out.println("你输入的是world"); 24 break; 25 case "java": 26 System.out.println("你输入的是java"); 27 break; 28 default: 29 System.out.println("没有找到你输入的数据"); 30 //break; 31 } 32 } 33 }
SwitchTest4.java【演示case穿透】
1 /* 2 用switch语句实现键盘录入月份，输出对应的季节 3 4 分析： 5 A:键盘录入一个月份，用Scanner实现 6 B:用switch语句实现即可 7 8 if语句和switch语句的区别? 9 if语句： 10 A:针对结果是boolean类型的判断 11 B:针对一个范围的判断 12 C:针对几个常量值的判断 13 14 switch语句： 15 针对几个常量值的判断 16 */ 17 import java.util.Scanner; 18 19 class SwitchTest4 { 20 public static void main(String[] args) { 21 //创建键盘录入对象 22 Scanner sc = new Scanner(System.in); 23 24 //录入数据 25 System.out.println("请输入月份(1-12)："); 26 int month = sc.nextInt(); 27 28 /* 29 switch(month) { 30 case 1: 31 System.out.println("冬季"); 32 break; 33 case 2: 34 System.out.println("冬季"); 35 break; 36 case 3: 37 System.out.println("春季"); 38 break; 39 case 4: 40 System.out.println("春季"); 41 break; 42 case 5: 43 System.out.println("春季"); 44 break; 45 case 6: 46 System.out.println("夏季"); 47 break; 48 case 7: 49 System.out.println("夏季"); 50 break; 51 case 8: 52 System.out.println("夏季"); 53 break; 54 case 9: 55 System.out.println("秋季"); 56 break; 57 case 10: 58 System.out.println("秋季"); 59 break; 60 case 11: 61 System.out.println("秋季"); 62 break; 63 case 12: 64 System.out.println("冬季"); 65 break; 66 default: 67 System.out.println("你输入的月份有误"); 68 } 69 */ 70 71 //这样写太麻烦了，我们使用一个我们不想使用的东西：case穿透 72 switch(month) { 73 case 1: 74 case 2: 75 case 12: 76 System.out.println("冬季"); 77 break; 78 case 3: 79 case 4: 80 case 5: 81 System.out.println("春季"); 82 break; 83 case 6: 84 case 7: 85 case 8: 86 System.out.println("夏季"); 87 break; 88 case 9: 89 case 10: 90 case 11: 91 System.out.println("秋季"); 92 break; 93 default: 94 System.out.println("你输入的月份有误"); 95 } 96 } 97 }
2:循环语句(掌握)
(1)有三种:for,while,do...while
(2)for循环语句
A:格式
for(初始化语句;判断条件语句;控制条件语句){
循环体语句;
}
执行流程：
a:执行初始化语句
b:执行判断条件语句
如果这里是true，就继续
如果这里是false，循环就结束
c:执行循环体语句
d:执行控制条件语句
e:回到b
B:注意事项
a:判断条件语句无论简单还是复杂，结果是boolean类型
b:循环体语句如果是一条，可以省略大括号，但是不建议
c:有分号就没有左大括号，有左大括号就没有分号
C:案例
a:输出10次HelloWorld
b:输出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==2
x%5==3
x%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(;;){}
ForDemo.java
1 /* 2 循环语句：for循环,while循环,do...while循环。 3 4 for循环格式： 5 for(初始化语句;判断条件语句;控制条件语句) { 6 循环体语句; 7 } 8 9 执行流程： 10 A:执行初始化语句 11 B:执行判断条件语句,看其返回值是true还是false 12 如果是true，就继续执行 13 如果是false，就结束循环 14 C:执行循环体语句; 15 D:执行控制条件语句 16 E:回到B继续。 17 18 注意事项： 19 A:判断条件语句无论简单还是复杂结果是boolean类型。 20 B:循环体语句如果是一条语句，大括号可以省略；如果是多条语句，大括号不能省略。建议永远不要省略。 21 C:一般来说：有左大括号就没有分号，有分号就没有左大括号 22 23 需求：请在控制台输出10次"HelloWorld" 24 */ 25 class ForDemo { 26 public static void main(String[] args) { 27 //最原始的做法 28 System.out.println("HelloWorld"); 29 System.out.println("HelloWorld"); 30 System.out.println("HelloWorld"); 31 System.out.println("HelloWorld"); 32 System.out.println("HelloWorld"); 33 System.out.println("HelloWorld"); 34 System.out.println("HelloWorld"); 35 System.out.println("HelloWorld"); 36 System.out.println("HelloWorld"); 37 System.out.println("HelloWorld"); 38 System.out.println("----------"); 39 40 //这种做法不好,代码的重复度太高。 41 //所以呢，我们用循环改进 42 for(int x=1;x<=10;x++) { 43 System.out.println("HelloWorld"); 44 } 45 } 46 }
ForDemo2.java
1 /* 2 需求：请在控制台输出数据1-10 3 */ 4 class ForDemo2 { 5 public static void main(String[] args) { 6 //原始做法 7 System.out.println(1); 8 System.out.println(2); 9 System.out.println(3); 10 System.out.println(4); 11 System.out.println(5); 12 System.out.println(6); 13 System.out.println(7); 14 System.out.println(8); 15 System.out.println(9); 16 System.out.println(10); 17 18 System.out.println("-------------"); 19 20 //如何改进呢?用循环改进 21 for(int x=1; x<=10; x++) { 22 System.out.println(x); 23 } 24 25 System.out.println("-------------"); 26 27 //从0开始 28 for(int x=0; x<10; x++) { 29 System.out.println(x+1); 30 } 31 } 32 }
ForDemo3.java
1 /* 2 需求：求出1-10之间数据之和 3 4 分析： 5 0+1=1 6 1+2=3 7 3+3=6 8 6+4=10 9 10+5=15 10 ... 11 12 由此可见我们要定义两个变量： 13 一个变量用于存储第一个加数，第一个加数其实保存的是以前的所有数据和。默认初始化值应该是0。 14 一个变量用于存储第二个加数，第二个加数其实就是每次的数据变化的值。 15 16 求和思想。 17 */ 18 class ForDemo3 { 19 public static void main(String[] args) { 20 //原始做法 21 System.out.println(1+2+3+4+5+6+7+8+9+10); 22 23 //定义第一个加数 24 int sum = 0; 25 26 for(int x=1; x<=10; x++) { 27 //这里的x其实是第二个加数 28 sum = sum + x; 29 /* 30 0 + 1 = 1 31 1 + 2 = 3 32 3 + 3 = 6 33 ... 34 */ 35 36 //sum += x; 37 } 38 39 System.out.println("sum:"+sum); 40 } 41 }
ForDemo4.java
1 /* 2 需求： 3 A:求1-100之和。 4 B:求出1-100之间偶数和 5 C:求出1-100之间奇数和(自己做) 6 */ 7 class ForDemo4 { 8 public static void main(String[] args) { 9 //求1-100之和。 10 int sum1 = 0; 11 12 for(int x=1; x<=100; x++) { 13 sum1 +=x; 14 } 15 16 System.out.println("1-100之和是："+sum1); 17 System.out.println("------------------"); 18 19 //求出1-100之间偶数和 20 //方式1 21 int sum2 = 0; 22 23 for(int x=1; x<=100; x++) { 24 if(x%2 == 0) { 25 sum2 += x; 26 } 27 } 28 29 System.out.println("1-100偶数之和是："+sum2); 30 System.out.println("------------------"); 31 32 //方式2 33 int sum3 = 0; 34 35 for(int x=0; x<=100; x+=2) { 36 sum3 += x; 37 } 38 39 System.out.println("1-100偶数之和是："+sum3); 40 System.out.println("------------------"); 41 } 42 }
ForDemo4.java【求阶乘】
1 /* 2 需求：求5的阶乘。 3 4 什么是阶乘呢? 5 n! = n*(n-1)! 规则 6 n! = n*(n-1)*(n-2)*...*3*2*1 7 8 求和思想。 9 求阶乘思想。 10 */ 11 class ForDemo5 { 12 public static void main(String[] args) { 13 //定义最终结果变量 14 int jc = 1; 15 16 //这里的x其实可以直接从2开始 17 //for(int x=1; x<=5; x++) 18 19 for(int x=2; x<=5; x++) { 20 jc *=x; 21 } 22 23 System.out.println("1-5的阶乘是："+jc); 24 } 25 }
ForDemo5.java【水仙花数】
1 /* 2 天将降大任于斯人也,必先盗其QQ,封其微博,收其wifi,夺其手机。让其静心学习Java欧耶。 3 4 需求：在控制台输出所有的”水仙花数” 5 6 分析： 7 我们都不知道什么叫"水仙花数"，你让我怎么做呢? 8 9 所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。 10 举例：153就是一个水仙花数。 11 153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153 12 13 A:三位数其实是告诉了我们范围。 14 B:通过for循环我们就可以实现获取每一个三位数 15 但是麻烦是如何获取这个三位数的个,十,百位上的数据 16 17 我们如何获取一个数据的个,十,百呢? 18 假设有个一个数据:153 19 ge: 153%10 = 3 20 shi: 153/10%10 = 5 21 bai：153/10/10%10 = 1 22 qian：x/10/10/10%10 23 wan: x/10/10/10/10%10 24 ... 25 26 C:让ge*ge*ge+shi*shi*shi+bai*bai*bai和该数据比较 27 如果相同，就把该数据在控制台输出。 28 */ 29 class ForDemo6 { 30 public static void main(String[] args) { 31 //三位数其实是告诉了我们范围。 32 for(int x=100; x<1000; x++) { 33 int ge = x%10; 34 int shi = x/10%10; 35 int bai = x/10/10%10; 36 37 //让ge*ge*ge+shi*shi*shi+bai*bai*bai和该数据比较 38 if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)) { 39 //如果相同，就把该数据在控制台输出。 40 System.out.println(x); 41 } 42 } 43 } 44 }
ForDemo7.java【回文数】
1 /* 2 练习： 3 请在控制台输出满足如下条件的五位数 4 个位等于万位 5 十位等于千位 6 个位+十位+千位+万位=百位 7 8 分析： 9 A:五位数就告诉了我们范围。 10 B:分解每一个五位数的个，十，百，千，万位上的数据 11 C:按照要求进行判断即可 12 */ 13 class ForDemo7 { 14 public static void main(String[] args) { 15 //五位数就告诉了我们范围。 16 for(int x=10000; x<100000; x++) { 17 //分解每一个五位数的个，十，百，千，万位上的数据 18 int ge = x%10; 19 int shi = x/10%10; 20 int bai = x/10/10%10; 21 int qian = x/10/10/10%10; 22 int wan = x/10/10/10/10%10; 23 24 //按照要求进行判断即可 25 if((ge==wan) && (shi==qian) && (ge+shi+qian+wan==bai)) { 26 System.out.println(x); 27 } 28 } 29 } 30 }
ForDemo8.java
1 /* 2 需求：统计”水仙花数”共有多少个 3 4 分析： 5 A:首先必须知道什么是水仙花数 6 所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。 7 举例：153就是一个水仙花数。 8 153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153 9 B:定义统计变量，初始化值是0 10 C:三位数告诉了我们范围，用for循环就可以搞定 11 D:获取每一个三位数的个，十，百的数据 12 E:按照要求进行判断 13 F:如果满足要求就计数。 14 */ 15 class ForDemo8 { 16 public static void main(String[] args) { 17 //定义统计变量，初始化值是0 18 int count = 0; 19 20 //三位数告诉了我们范围，用for循环就可以搞定 21 for(int x=100; x<1000; x++) { 22 //获取每一个三位数的个，十，百的数据 23 int ge = x%10; 24 int shi = x/10%10; 25 int bai = x/10/10%10; 26 27 //按照要求进行判断 28 if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)) { 29 //如果满足要求就计数。 30 count++; 31 } 32 } 33 34 System.out.println("水仙花数共有"+count+"个"); 35 } 36 }
ForDemo9.java
1 /* 2 需求：请统计1-1000之间同时满足如下条件的数据有多少个： 3 对3整除余2 4 对5整除余3 5 对7整除余2 6 7 分析： 8 A:定义统计变量,初始化值是0 9 B:1-1000之间是一个范围，用for很容易就可以实现。 10 C:每个数据要同时满足如下要求 11 x%3==2 12 x%5==3 13 x%7==2 14 D:如果满足条件，统计数据++即可，最后输出统计变量 15 */ 16 class ForDemo9 { 17 public static void main(String[] args) { 18 //定义统计变量,初始化值是0 19 int count = 0; 20 21 //1-1000之间是一个范围，用for很容易就可以实现。 22 for(int x=1; x<=1000; x++) { 23 /* 24 每个数据要同时满足如下要求 25 x%3==2 26 x%5==3 27 x%7==2 28 */ 29 if(x%3==2 && x%5==3 && x%7==2) { 30 count++; 31 System.out.println(x); 32 } 33 } 34 35 //输出数据 36 System.out.println("满足这样条件的数据共有："+count+"个"); 37 } 38 }
WhileDemo.java
1 /* 2 while循环的基本格式： 3 while(判断条件语句) { 4 循环体语句; 5 } 6 7 扩展格式： 8 9 初始化语句; 10 while(判断条件语句) { 11 循环体语句; 12 控制条件语句; 13 } 14 15 通过这个格式，我们就可以看到其实和for循环是差不多的。 16 17 for(初始化语句;判断条件语句;控制条件语句) { 18 循环体语句; 19 } 20 */ 21 class WhileDemo { 22 public static void main(String[] args) { 23 //输出10次"HelloWorld" 24 //for语句版 25 for(int x=0; x<10; x++) { 26 System.out.println("HelloWorld"); 27 } 28 System.out.println("--------------"); 29 //while语句版 30 int x=0; 31 while(x<10) { 32 System.out.println("HelloWorld"); 33 x++; 34 } 35 36 } 37 }
WhileDemo2.java
1 /* 2 练习：用while循环实现 3 左边：求出1-100之和 4 右边：统计水仙花数有多少个 5 6 初始化语句; 7 while(判断条件语句) { 8 循环体语句; 9 控制条件语句; 10 } 11 12 13 14 for(初始化语句;判断条件语句;控制条件语句) { 15 循环体语句; 16 } 17 18 */ 19 class WhileDemo2 { 20 public static void main(String[] args) { 21 //求出1-100之和 22 //for语句版本 23 int sum = 0; 24 25 for(int x=1; x<=100; x++) { 26 sum+=x; 27 } 28 29 System.out.println("sum:"+sum); 30 System.out.println("--------"); 31 //while语句版本 32 int sum2 = 0; 33 34 int y=1; 35 while(y<=100) { 36 sum2+=y; 37 y++; 38 } 39 40 System.out.println("sum2:"+sum2); 41 System.out.println("--------"); 42 } 43 }
WhileDemo3.java
1 /* 2 需求：统计水仙花数有多少个 3 */ 4 class WhileDemo3 { 5 public static void main(String[] args) { 6 //for循环版本 7 int count = 0; 8 9 for(int x=100; x<1000; x++) { 10 int ge = x%10; 11 int shi = x/10%10; 12 int bai = x/10/10%10; 13 14 if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) { 15 count++; 16 } 17 } 18 19 System.out.println("count:"+count); 20 System.out.println("------------"); 21 22 //while循环版本 23 int count2 = 0; 24 25 int y = 100; 26 while(y<1000) { 27 int ge = y%10; 28 int shi = y/10%10; 29 int bai = y/10/10%10; 30 31 if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == y) { 32 count2++; 33 } 34 35 y++; 36 } 37 38 System.out.println("count2:"+count2); 39 } 40 }
WhileDemo4.java
1 /* 2 while循环和for循环的区别? 3 使用区别：如果你想在循环结束后，继续使用控制条件的那个变量，用while循环，否则用for循环。不知道用for循环。 4 因为变量及早的从内存中消失，可以提高内存的使用效率。 5 6 其实还有一种场景的理解: 7 如果是一个范围的，用for循环非常明确。 8 如果是不明确要做多少次，用while循环较为合适。 9 举例：吃葡萄。 10 */ 11 class WhileDemo4 { 12 public static void main(String[] args) { 13 //for循环实现 14 for(int x=0; x<10; x++) { 15 System.out.println("学习Java技术哪家强,中国北京传智播客"); 16 } 17 //这里不能在继续访问了 18 //System.out.println(x); 19 20 //while循环实现 21 int y = 0; 22 while(y<10) { 23 System.out.println("学习Java技术哪家强,中国北京传智播客"); 24 y++; 25 } 26 //这里是可以继续访问的 27 System.out.println(y); 28 } 29 }
WhileDemo5.java
1 /* 2 我国最高山峰是珠穆朗玛峰：8848m，我现在有一张足够大的纸张，厚度为：0.01m。 3 请问，我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度? 4 5 分析： 6 A:定义一个统计变量，默认值是0 7 B:最高山峰是珠穆朗玛峰：8848m这是最终的厚度 8 我现在有一张足够大的纸张，厚度为：0.01m这是初始厚度 9 C:我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度? 10 折叠一次有什么变化呢?就是厚度是以前的2倍。 11 D:只要每次变化的厚度没有超过珠穆朗玛峰的高度，就折叠，统计变量++ 12 E:输出统计变量。 13 */ 14 15 class WhileDemo5 { 16 public static void main(String[] args) { 17 //定义一个统计变量，默认值是0 18 int count = 0; 19 20 //最高山峰是珠穆朗玛峰：8848m这是最终的厚度 21 //我现在有一张足够大的纸张，厚度为：0.01m这是初始厚度 22 //为了简单，我把0.01变成1，同理8848就变成了884800 23 int end = 884800; 24 int start = 1; 25 26 while(start<end) { 27 //只要每次变化的厚度没有超过珠穆朗玛峰的高度，就折叠，统计变量++ 28 count++; 29 30 //折叠一次有什么变化呢?就是厚度是以前的2倍。 31 start *= 2; 32 33 System.out.println("第"+count+"次厚度是"+start); 34 } 35 36 //输出统计变量。 37 System.out.println("要叠"+count+"次"); 38 } 39 }
DoWhileDemo.java
1 /* 2 do...while循环的基本格式： 3 do { 4 循环体语句; 5 }while(判断条件语句); 6 7 扩展格式； 8 初始化语句; 9 do { 10 循环体语句; 11 控制条件语句; 12 }while(判断条件语句); 13 */ 14 class DoWhileDemo { 15 public static void main(String[] args) { 16 //输出10次HelloWorld。 17 int x = 0; 18 do { 19 System.out.println("HelloWorld"); 20 x++; 21 }while(x<10); 22 23 System.out.println("--------------"); 24 25 //求和1-100 26 int sum = 0; 27 int a = 1; 28 do { 29 sum += a; 30 a++; 31 }while(a<=100); 32 33 System.out.println(sum); 34 } 35 }
DoWhileDemo2.java
1 /* 2 循环语句的区别: 3 do...while循环至少执行一次循环体。 4 而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句。 5 6 那么，我们一般使用哪种循环呢? 7 优先考虑for，其次考虑while，最后考虑do...while 8 */ 9 class DoWhileDemo2 { 10 public static void main(String[] args) { 11 int x = 3; 12 while(x < 3) { 13 System.out.println("我爱林青霞"); 14 x++; 15 } 16 17 System.out.println("--------------"); 18 19 int y = 3; 20 do { 21 System.out.println("我爱林青霞"); 22 y++; 23 }while(y < 3); 24 } 25 }
DoWhileDemo3.java
1 /* 2 注意死循环： 3 A:一定要注意控制条件语句控制的那个变量的问题，不要弄丢了，否则就容易死循环。 4 B:两种最简单的死循环格式 5 while(true){...} 6 for(;;){...} 7 8 */ 9 class DoWhileDemo3 { 10 public static void main(String[] args) { 11 int x = 0; 12 while(x < 10) { 13 System.out.println(x); 14 x++; 15 } 16 System.out.println("--------------"); 17 18 /* 19 while(true) { 20 System.out.println("今天我很高兴，学习了死循环"); 21 } 22 */ 23 24 for(;;){ 25 System.out.println("今天我很高兴，学习了死循环"); 26 } 27 28 //System.out.println("--------------"); 29 } 30 }
循环的嵌套
ForForDemo.java
1 /* 2 需求：请输出一个4行5列的星星(*)图案。 3 结果： 4 ***** 5 ***** 6 ***** 7 ***** 8 9 循环嵌套：就是循环语句的循环体本身是一个循环语句。 10 11 通过结果我们知道这样的一个结论： 12 外循环控制行数 13 内循环控制列数 14 */ 15 class ForForDemo { 16 public static void main(String[] args) { 17 //原始做法 18 System.out.println("*****"); 19 System.out.println("*****"); 20 System.out.println("*****"); 21 System.out.println("*****"); 22 System.out.println("-------------"); 23 24 //虽然可以完成需求，但是不是很好 25 //如果是多行多列就会比较麻烦 26 //所以我们准备改进 27 //如何改进呢? 28 //我先考虑如何实现一行*的问题 29 //System.out.println("*****"); 30 //我们要想的是如何实现一次输出一颗*的问题 31 //System.out.println("*"); 32 //System.out.println("*"); 33 //现在虽然可以一次一颗*，但是却换行了，我要求不能换行，怎么办呢? 34 //输出语句的另一种格式：System.out.print(); 这个是不带换行的 35 //System.out.print("*"); 36 //System.out.print("*"); 37 //System.out.print("*"); 38 //System.out.print("*"); 39 //System.out.print("*"); 40 //如果我要在一行上打出多颗*，比较麻烦，而代码是重复的，所以我决定用循环改进 41 for(int x=0; x<5; x++) { 42 System.out.print("*"); 43 } 44 //我们可以通过空的输出语句实现换行：System.out.println(); 45 System.out.println(); 46 47 //既然我可以打出一行，我就可以打出第二行 48 for(int x=0; x<5; x++) { 49 System.out.print("*"); 50 } 51 //我们可以通过空的输出语句实现换行：System.out.println(); 52 System.out.println(); 53 54 //同理打出第三行，第四行 55 for(int x=0; x<5; x++) { 56 System.out.print("*"); 57 } 58 //我们可以通过空的输出语句实现换行：System.out.println(); 59 System.out.println(); 60 61 //既然我可以打出一行，我就可以打出第二行 62 for(int x=0; x<5; x++) { 63 System.out.print("*"); 64 } 65 //我们可以通过空的输出语句实现换行：System.out.println(); 66 System.out.println(); 67 System.out.println("-----------------"); 68 //同样的代码出现了4次，说明我们程序写的不好，用循环改进 69 for(int y=0; y<4; y++) { 70 for(int x=0; x<5; x++) { 71 System.out.print("*"); 72 } 73 //我们可以通过空的输出语句实现换行：System.out.println(); 74 System.out.println(); 75 } 76 } 77 }
ForForDemo2.java
/* 需求：请输出下列的形状 * ** *** **** ***** */ 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(); } } }
ForForDemo3.java
1 /* 2 需求：在控制台输出九九乘法表。 3 4 首先我们写出九九乘法表： 5 1*1=1 6 1*2=2 2*2=4 7 1*3=3 2*3=6 3*3=9 8 1*4=4 2*4=8 3*4=12 4*4=16 9 ... 10 1*9=9 2*9=18 3*9=27 ... 11 12 我们先把这个九九乘法表看出是这样的一个形状： 13 * 14 ** 15 *** 16 **** 17 ***** 18 ****** 19 ******* 20 ******** 21 ********* 22 23 注意： 24 'x' x表示任意，这种做法叫转移字符。 25 26 ' ' tab键的位置 27 ' ' 回车 28 ' ' 换行 29 */ 30 class ForForDemo3 { 31 public static void main(String[] args) { 32 for(int x=0; x<9; x++) { 33 for(int y=0; y<=x; y++) { 34 System.out.print("*"); 35 } 36 System.out.println(); 37 } 38 System.out.println("--------------"); 39 //为了使用数据，我们从1开始 40 for(int x=1; x<=9; x++) { 41 for(int y=1; y<=x; y++) { 42 System.out.print(y+"*"+x+"="+y*x+" "); 43 } 44 System.out.println(); 45 } 46 } 47 }
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,程序就不会在继续往后执行。
BreakDemo.java
1 /* 2 控制跳转语句： 3 break:中断 4 continue:继续 5 return:返回 6 7 break:中断的意思 8 使用场景： 9 A:switch语句中 10 B:循环语句中。 11 (循环语句中加入了if判断的情况) 12 注意：离开上面的两个场景，无意义。 13 14 如何使用呢? 15 A:跳出单层循环 16 B:跳出多层循环 17 要想实现这个效果，就必须知道一个东西。带标签的语句。 18 格式： 19 标签名: 语句 20 */ 21 class BreakDemo { 22 public static void main(String[] args) { 23 //在 switch 或 loop 外部中断 24 //break; 25 26 //跳出单层循环 27 for(int x=0; x<10; x++) { 28 if(x == 3) { 29 break; 30 } 31 System.out.println("HelloWorld"); 32 } 33 34 System.out.println("over"); 35 System.out.println("-------------"); 36 37 wc:for(int x=0; x<3; x++) { 38 nc:for(int y=0; y<4; y++) { 39 if(y == 2) { 40 //break nc; 41 break wc; 42 } 43 System.out.print("*"); 44 } 45 System.out.println(); 46 } 47 } 48 }
ContinueDemo.java
1 /* 2 continue:继续 3 4 使用场景： 5 循环中。离开此场景无意义。 6 7 测试，找到和break的区别： 8 break:跳出单层循环 9 continue:跳出一次循环，进入下一次的执行 10 11 练习题： 12 for(int x=1; x<=10; x++) { 13 if(x%3==0) { 14 //在此处填写代码 15 } 16 System.out.println(“Java基础班”); 17 } 18 19 我想在控制台输出2次:“Java基础班“ 20 break; 21 我想在控制台输出7次:“Java基础班“ 22 continue; 23 我想在控制台输出13次:“Java基础班“ 24 System.out.println(“Java基础班”); 25 26 27 */ 28 class ContinueDemo { 29 public static void main(String[] args) { 30 for(int x=0; x<10; x++) { 31 if(x == 3) { 32 //break; 33 continue; 34 } 35 36 System.out.println(x); 37 } 38 } 39 }
ReturnDemo.java
1 /* 2 return:返回 3 4 其实它的作用不是结束循环的，而是结束方法的。 5 */ 6 class ReturnDemo { 7 public static void main(String[] args) { 8 for(int x=0; x<10; x++) { 9 if(x == 2) { 10 System.out.println("退出"); 11 //break; 12 //continue; 13 return; 14 } 15 16 System.out.println(x); 17 } 18 19 System.out.println("over"); 20 } 21 }
WhileDemo.java
1 /* 2 需求：小芳的妈妈每天给她2.5元钱，她都会存起来，但是， 3 每当这一天是存钱的第5天或者5的倍数的话，她都会花去6元钱， 4 请问，经过多少天，小芳才可以存到100元钱。 5 6 分析： 7 A:小芳的妈妈每天给她2.5元钱 8 double dayMoney = 2.5; 9 B:她都会存起来 10 double daySum = 0; 11 C:从第一天开始存储 12 int dayCount = 1; 13 D:经过多少天，小芳才可以存到100元钱。 14 double result = 100; 15 E:这一天是存钱的第5天或者5的倍数的话，她都会花去6元钱， 16 说明要判断dayCount的值，如果对5整除就减去6元钱。 17 daySum -= 6; 18 由此还隐含了一个问题，就是如果不是5的倍数天的话，钱要累加 19 daySum += dayMoney; 20 F:因为不知道是多少天，所以我用死循环，一旦超过100元我就退出循环。 21 */ 22 class WhileDemo { 23 public static void main(String[] args) { 24 //每天要存储的钱是2.5元 25 double dayMoney = 2.5; 26 27 //存钱的初始化值是0 28 double daySum = 0; 29 30 //从第一天开始存储 31 int dayCount = 0; 32 33 //最终存储不小于100就不存储了 34 int result = 100; 35 36 //因为不知道是多少天，所以我用死循环， 37 while(true) { 38 //天数变化 39 dayCount++; 40 41 //累加钱 42 daySum += dayMoney; 43 44 if(dayCount%5 == 0) { 45 //花去6元钱 46 daySum -= 6; 47 System.out.println("第"+dayCount+"天花了6元钱"); 48 } 49 50 //一旦超过100元我就退出循环。 51 if(daySum >= result) { 52 System.out.println("共花了"+dayCount+"天存储了100元"); 53 break; 54 } 59 } 60 } 61 }
使用while循环改写：
注意：不要把result 的数据类型改为int，否则result += 2.5会把结果强制转为int
public class OperatorDemo { public static void main(String[] args) { double result = 0; int count = 0; while(result < 100){ count ++; result +=2.5; if ( count % 5 == 0){ result -=6; } System.out.println("第"+count+"天"+"存了"+result); } System.out.println(count); } }