Java基础-04.总结switch,for,while,do。while跳转语句

  1. 云栖社区>
  2. 博客>
  3. 正文

Java基础-04.总结switch,for,while,do。while跳转语句

奋斗蒙 2016-11-24 10:22:00 浏览1669
展开阅读全文

你需要的是什么,直接评论留言。

获取更多资源加微信公众号“Java帮帮” (是公众号,不是微信好友哦)

还有“Java帮帮”今日头条号,技术文章与新闻,每日更新,欢迎阅读

学习交流请加Java帮帮交流QQ群553841695

分享是一种美德,分享更快乐!


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以后可以
(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:执行到末尾就结束了
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;
}
}
}


(5)案例:
A:键盘录入一个数字(1-7),输出对应的星期几。
B:单项选择题
C:键盘录入一个字符串的问题
String s = sc.nextLine();
D:根据给定的月份,案例:
/* A:
键盘录入一个数据,根据这个数据,我们输出对应的星期?
键盘录入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;
}
}
}


/*    B:
模拟单项选择题。

分析:
A:出一个选择题,然后供你选择。
B:键盘录入选择的数据。
C:根据选择来给出你选择的结论。
*/
import java.util.Scanner;


class SwitchTest2 {
public static void main(String[] args) {
//出一个选择题,然后供你选择。
//由于我们现在没有办法键盘录入得到一个'A','B'
//这样的东西,我就用65,66这样的值替代
//将来我们获取到这样的值以后,强制转换为字符类型
System.out.println("下面的几个人你最爱谁?");
System.out.println("65 林青霞");
System.out.println("66 张曼玉");
System.out.println("67 刘德华");
System.out.println("68 王力宏");

//键盘录入选择的数据。
Scanner sc = new Scanner(System.in);

System.out.println("请输入你的选择:");
int choiceNumber = sc.nextInt();

//强制转换为字符类型
char choice = (char) choiceNumber;

switch(choice) {
case 'A':
System.out.println("恭喜你,选择正确");
break;
case 'B':
System.out.println("不好意思,你选择有误");
break;
case 'C':
System.out.println("不好意思,你选择有误");
break;
case 'D':
System.out.println("不好意思,你选择有误");
break;
default:
System.out.println("没有该选项");
break;
}
}
}


/*    C:


根据你键盘录入的字符串,判断是否有满足要求的,如果有就输出。
否则,提示有误。

String s = sc.nextLine();
*/
import java.util.Scanner;


class SwitchTest3 {
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;
}
}
}


/*    D:


用switch语句实现键盘录入月份,输出对应的季节

分析:
A:键盘录入一个月份,用Scanner实现
B:用switch语句实现即可

if语句和switch语句的区别?
if语句:
A:针对结果是boolean类型的判断
B:针对一个范围的判断
C:针对几个常量值的判断

switch语句:
针对几个常量值的判断
*/
import java.util.Scanner;


class SwitchTest4 {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);

//录入数据
System.out.println("请输入月份(1-12):");
int month = sc.nextInt();

/*
switch(month) {
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;
case 11:
System.out.println("秋季");
break;
case 12:
System.out.println("冬季");
break;
default:
System.out.println("你输入的月份有误");
}
*/

//这样写太麻烦了,我们使用一个我们不想使用的东西:case穿透
switch(month) {
case 1:
case 2:
case 12:
System.out.println("冬季");
break;
case 3:
case 4:
case 5:
System.out.println("春季");
break;
case 6:
case 7:
case 8:
System.out.println("夏季");
break;
case 9:
case 10:
case 11:
System.out.println("秋季");
break;
default:
System.out.println("你输入的月份有误");
}
}
}


扩展


/*
看程序写结果
*/
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);
}
}
(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:回到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
/*    a:
循环语句:for循环,while循环,do...while循环。

for循环格式:
for(初始化语句;判断条件语句;控制条件语句) {
循环体语句;
}

执行流程:
A:执行初始化语句
B:执行判断条件语句,看其返回值是true还是false
如果是true,就继续执行
如果是false,就结束循环
C:执行循环体语句;
D:执行控制条件语句
E:回到B继续。

注意事项:
A:判断条件语句无论简单还是复杂结果是boolean类型。
B:循环体语句如果是一条语句,大括号可以省略;如果是多条语句,大括号不能省略。建议永远不要省略。
C:一般来说:有左大括号就没有分号,有分号就没有左大括号

需求:请在控制台输出10次"HelloWorld"
*/
class ForDemo {
public static void main(String[] args) {
//最原始的做法
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("----------");

//这种做法不好,代码的重复度太高。
//所以呢,我们用循环改进
for(int x=1;x<=10;x++) {
System.out.println("HelloWorld");
}
}
}


/*    b:
需求:请在控制台输出数据1-10
*/
class ForDemo2 {
public static void main(String[] args) {
//原始做法
System.out.println(1);
System.out.println(2);
System.out.println(3);
System.out.println(4);
System.out.println(5);
System.out.println(6);
System.out.println(7);
System.out.println(8);
System.out.println(9);
System.out.println(10);

System.out.println("-------------");

//如何改进呢?用循环改进
for(int x=1; x<=10; x++) {
System.out.println(x);
}

System.out.println("-------------");

//从0开始
for(int x=0; x<10; x++) {
System.out.println(x+1);
}
}
}


/*    d:
需求:求出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) {
//原始做法
System.out.println(1+2+3+4+5+6+7+8+9+10);

//定义第一个加数
int sum = 0;

for(int x=1; x<=10; x++) {
//这里的x其实是第二个加数
sum = sum + x;
/*
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
...
*/

//sum += x;
}

System.out.println("sum:"+sum);
}
}


/*    e:
需求:
A:求1-100之和。
B:求出1-100之间偶数和
C:求出1-100之间奇数和(自己做)
*/
class ForDemo4 {
public static void main(String[] args) {
//求1-100之和。
int sum1 = 0;

for(int x=1; x<=100; x++) {
sum1 +=x;
}

System.out.println("1-100之和是:"+sum1);
System.out.println("------------------");

//求出1-100之间偶数和
//方式1
int sum2 = 0;

for(int x=1; x<=100; x++) {
if(x%2 == 0) {
sum2 += x;
}
}

System.out.println("1-100偶数之和是:"+sum2);
System.out.println("------------------");

//方式2
int sum3 = 0;

for(int x=0; x<=100; x+=2) {
sum3 += x;
}

System.out.println("1-100偶数之和是:"+sum3);
System.out.println("------------------");
}
}
/*    f:
需求:求5的阶乘。

什么是阶乘呢?
n! = n*(n-1)! 规则
n! = n*(n-1)*(n-2)*...*3*2*1

求和思想。
求阶乘思想。
*/
class ForDemo5 {
public static void main(String[] args) {
//定义最终结果变量
int jc = 1;

//这里的x其实可以直接从2开始
//for(int x=1; x<=5; x++) 

for(int x=2; x<=5; x++) {
jc *=x;
}

System.out.println("1-5的阶乘是:"+jc);
}
}
/*    g:
天将降大任于斯人也,必先盗其QQ,封其微博,收其wifi,夺其手机。让其静心学习Java欧耶。


需求:在控制台输出所有的”水仙花数”

分析:
我们都不知道什么叫"水仙花数",你让我怎么做呢?

所谓的水仙花数是指一个三位数,其各位数字的立方和等于该数本身。
举例:153就是一个水仙花数。
153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153


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);
}
}
}
}
/*    h:


需求:统计”水仙花数”共有多少个

分析:
A:首先必须知道什么是水仙花数
所谓的水仙花数是指一个三位数,其各位数字的立方和等于该数本身。
举例:153就是一个水仙花数。
153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153
B:定义统计变量,初始化值是0
C:三位数告诉了我们范围,用for循环就可以搞定
D:获取每一个三位数的个,十,百的数据
E:按照要求进行判断
F:如果满足要求就计数。
*/
class ForDemo8 {
public static void main(String[] args) {
//定义统计变量,初始化值是0
int count = 0;

//三位数告诉了我们范围,用for循环就可以搞定
for(int x=100; x<1000; x++) {
//获取每一个三位数的个,十,百的数据
int ge = x%10;
int shi = x/10%10;
int bai = x/10/10%10;

//按照要求进行判断
if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)) {
//如果满足要求就计数。
count++;
}
}

System.out.println("水仙花数共有"+count+"个");
}
}
/*    i:


练习:
请在控制台输出满足如下条件的五位数
个位等于万位
十位等于千位
个位+十位+千位+万位=百位

分析:
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/10/10%10;
int qian = x/10/10/10%10;
int wan = x/10/10/10/10%10;

//按照要求进行判断即可
if((ge==wan) && (shi==qian) && (ge+shi+qian+wan==bai)) {
System.out.println(x);
}
}
}
}


/*    j:
需求:请统计1-1000之间同时满足如下条件的数据有多少个:
对3整除余2
对5整除余3
对7整除余2


分析:
A:定义统计变量,初始化值是0
B:1-1000之间是一个范围,用for很容易就可以实现。
C:每个数据要同时满足如下要求
x%3==2
x%5==3
x%7==2
D:如果满足条件,统计数据++即可,最后输出统计变量
*/
class ForDemo9 {
public static void main(String[] args) {
//定义统计变量,初始化值是0
int count = 0;

//1-1000之间是一个范围,用for很容易就可以实现。
for(int x=1; x<=1000; x++) {
/*
每个数据要同时满足如下要求
x%3==2
x%5==3
x%7==2
*/
if(x%3==2 && x%5==3 && x%7==2) {
count++;
System.out.println(x);
}
}

//输出数据
System.out.println("满足这样条件的数据共有:"+count+"个");
}
}


(3)while循环
A:基本格式
while(判断条件语句) {
循环体语句;
}

扩展格式:
初始化语句;
while(判断条件语句){
循环体语句;
控制条件语句;
}
通过查看这个格式,我们就知道while循环可以和for循环等价转换。
/*
while循环的基本格式:
while(判断条件语句) {
循环体语句;
}

扩展格式:

初始化语句;
   while(判断条件语句) {
循环体语句;
控制条件语句;
}

通过这个格式,我们就可以看到其实和for循环是差不多的。

for(初始化语句;判断条件语句;控制条件语句) {
循环体语句;
}
*/
class WhileDemo {
public static void main(String[] args) {
//输出10次"HelloWorld"
//for语句版
for(int x=0; x<10; x++) {
System.out.println("HelloWorld");
}
System.out.println("--------------");
//while语句版
int x=0;
while(x<10) {
System.out.println("HelloWorld");
x++;
}

}
}
B:while的练习
把for语句的练习用while改进


/*
练习:用while循环实现
左边:求出1-100之和
右边:统计水仙花数有多少个

初始化语句;
while(判断条件语句) {
循环体语句;
控制条件语句;
}



for(初始化语句;判断条件语句;控制条件语句) {
循环体语句;
}


*/
class WhileDemo2 {
public static void main(String[] args) {
//求出1-100之和
//for语句版本
int sum = 0;

for(int x=1; x<=100; x++) {
sum+=x;
}

System.out.println("sum:"+sum);
System.out.println("--------");
//while语句版本
int sum2 = 0;

int y=1;
while(y<=100) {
sum2+=y;
y++;
}

System.out.println("sum2:"+sum2);
System.out.println("--------");
}
}


/*
需求:统计水仙花数有多少个
*/
class WhileDemo3 {
public static void main(String[] args) {
//for循环版本
int count = 0;

for(int x=100; x<1000; x++) {
int ge = x%10;
int shi = x/10%10;
int bai = x/10/10%10;

if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) {
count++;
}
}

System.out.println("count:"+count);
System.out.println("------------");

//while循环版本
int count2 = 0;

int y = 100;
while(y<1000) {
int ge = y%10;
int shi = y/10%10;
int bai = y/10/10%10;

if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == y) {
count2++;
}

y++;
}

System.out.println("count2:"+count2);
}
}

C:for和while的区别
a:使用上的区别
for语句的那个控制条件变量,在循环结束后不能在使用了。
而while的可以继续使用。
b:理解上的区别
for适合于一个范围的判断
while适合次数不明确的
举例:吃葡萄
/*
while循环和for循环的区别?
使用区别:如果你想在循环结束后,继续使用控制条件的那个变量,用while循环,否则用for循环。不知道用for循环。
         因为变量及早的从内存中消失,可以提高内存的使用效率。
 
其实还有一种场景的理解:
如果是一个范围的,用for循环非常明确。
如果是不明确要做多少次,用while循环较为合适。
举例:吃葡萄。
*/
class WhileDemo4 {
public static void main(String[] args) {
//for循环实现
for(int x=0; x<10; x++) {
System.out.println("学习Java技术哪家强,中国北京传智播客");
}
//这里不能在继续访问了
//System.out.println(x);

//while循环实现
int y = 0;
while(y<10) {
System.out.println("学习Java技术哪家强,中国北京传智播客");
y++;
}
//这里是可以继续访问的
System.out.println(y);
}

D:案例:
a:珠穆朗玛峰问题
b:小芳存钱问题(break以后才能做)
/*    a:


我国最高山峰是珠穆朗玛峰:8848m,我现在有一张足够大的纸张,厚度为:0.01m。
请问,我折叠多少次,就可以保证厚度不低于珠穆朗玛峰的高度?


分析:
A:定义一个统计变量,默认值是0
B:最高山峰是珠穆朗玛峰:8848m这是最终的厚度
 我现在有一张足够大的纸张,厚度为:0.01m这是初始厚度
C:我折叠多少次,就可以保证厚度不低于珠穆朗玛峰的高度?
 折叠一次有什么变化呢?就是厚度是以前的2倍。
D:只要每次变化的厚度没有超过珠穆朗玛峰的高度,就折叠,统计变量++
E:输出统计变量。
*/


class WhileDemo5 {
public static void main(String[] args) {
//定义一个统计变量,默认值是0
int count = 0;

//最高山峰是珠穆朗玛峰:8848m这是最终的厚度
//我现在有一张足够大的纸张,厚度为:0.01m这是初始厚度
//为了简单,我把0.01变成1,同理8848就变成了884800
int end = 884800;
int start = 1;

while(start<end) {
//只要每次变化的厚度没有超过珠穆朗玛峰的高度,就折叠,统计变量++
count++;

//折叠一次有什么变化呢?就是厚度是以前的2倍。
start *= 2;

System.out.println("第"+count+"次厚度是"+start);
}

//输出统计变量。
System.out.println("要叠"+count+"次");
}
}


/*    b:
需求:小芳的妈妈每天给她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;
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;

//因为不知道是多少天,所以我用死循环,
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++;
}
}
}
(4)do...while循环
A:基本格式
do {
循环体语句;
}while(判断条件语句);

扩展格式:
初始化语句;
do {
循环体语句;
控制条件语句;
}while(判断条件语句);

通过查看格式,我们就可以看出其实三种循环的格式可以是统一的。
/*
do...while循环的基本格式:
do {
循环体语句;
}while(判断条件语句);

扩展格式;
初始化语句;
do {
循环体语句;
控制条件语句;
}while(判断条件语句);
*/
class DoWhileDemo {
public static void main(String[] args) {
//输出10次HelloWorld。
int x = 0;
do {
System.out.println("HelloWorld");
x++;
}while(x<10);

System.out.println("--------------");

//求和1-100
int sum = 0;
int a = 1;
do {
sum += a;
a++;
}while(a<=100);

System.out.println(sum);
}
}
B:三种循环的区别
a:do...while循环至少执行一次循环体
b:for和while必须先判断条件是否是true,然后后才能决定是否执行循环体
/*
循环语句的区别:
do...while循环至少执行一次循环体。
而for,while循环必须先判断条件是否成立,然后决定是否执行循环体语句。

那么,我们一般使用哪种循环呢?
优先考虑for,其次考虑while,最后考虑do...while
*/
class DoWhileDemo2 {
public static void main(String[] args) {
int x = 3;
while(x < 3) {
System.out.println("我爱林青霞");
x++;
}

System.out.println("--------------");

int y = 3;
do {
System.out.println("我爱林青霞");
y++;
}while(y < 3);
}
}
(5)循环使用的注意事项(死循环)
A:一定要注意修改控制条件,否则容易出现死循环。
B:最简单的死循环格式
a:while(true){...}

b:for(;;){}
/*
注意死循环:
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("今天我很高兴,学习了死循环");
}
*/

for(;;){
System.out.println("今天我很高兴,学习了死循环");
}

//System.out.println("--------------");
}
}
(6)循环嵌套
/*
需求:请输出一个4行5列的星星(*)图案。
结果:
*****
*****
*****
*****

循环嵌套:就是循环语句的循环体本身是一个循环语句。

通过结果我们知道这样的一个结论:
外循环控制行数
内循环控制列数
*/
class ForForDemo {
public static void main(String[] args) {
//原始做法
System.out.println("*****");
System.out.println("*****");
System.out.println("*****");
System.out.println("*****");
System.out.println("-------------");

//虽然可以完成需求,但是不是很好
//如果是多行多列就会比较麻烦
//所以我们准备改进
//如何改进呢?
//我先考虑如何实现一行*的问题
//System.out.println("*****");
//我们要想的是如何实现一次输出一颗*的问题
//System.out.println("*");
//System.out.println("*");
//现在虽然可以一次一颗*,但是却换行了,我要求不能换行,怎么办呢?
//输出语句的另一种格式:System.out.print(); 这个是不带换行的
//System.out.print("*");
//System.out.print("*");
//System.out.print("*");
//System.out.print("*");
//System.out.print("*");
//如果我要在一行上打出多颗*,比较麻烦,而代码是重复的,所以我决定用循环改进
for(int x=0; x<5; x++) {
System.out.print("*");
}
//我们可以通过空的输出语句实现换行:System.out.println();
System.out.println();

//既然我可以打出一行,我就可以打出第二行
for(int x=0; x<5; x++) {
System.out.print("*");
}
//我们可以通过空的输出语句实现换行:System.out.println();
System.out.println();

//同理打出第三行,第四行
for(int x=0; x<5; x++) {
System.out.print("*");
}
//我们可以通过空的输出语句实现换行:System.out.println();
System.out.println();

//既然我可以打出一行,我就可以打出第二行
for(int x=0; x<5; x++) {
System.out.print("*");
}
//我们可以通过空的输出语句实现换行:System.out.println();
System.out.println();
System.out.println("-----------------");
//同样的代码出现了4次,说明我们程序写的不好,用循环改进
for(int y=0; y<4; y++) {
for(int x=0; x<5; x++) {
System.out.print("*");
}
//我们可以通过空的输出语句实现换行:System.out.println();
System.out.println();
}
}
}


/*
需求:请输出下列的形状
*
**
***
****
*****
*/
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*4=4 2*4=8 3*4=12 4*4=16
...
1*9=9 2*9=18 3*9=27 ...

我们先把这个九九乘法表看出是这样的一个形状:
*
**
***
****
*****
******
*******
********
*********

注意:
'\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();
}
}
}

3:控制跳转语句(掌握)
(1)break:中断的意思
A:用在循环和switch语句中,离开此应用场景无意义。
B:作用
a:跳出单层循环
b:跳出多层循环,需要标签语句的配合


/*
控制跳转语句:
break:中断
continue:继续
return:返回

break:中断的意思
使用场景:
A:switch语句中
B:循环语句中。
(循环语句中加入了if判断的情况)
注意:离开上面的两个场景,无意义。

如何使用呢?
A:跳出单层循环
B:跳出多层循环
要想实现这个效果,就必须知道一个东西。带标签的语句。
格式:
标签名: 语句
*/
class BreakDemo {
public static void main(String[] args) {
//在 switch 或 loop 外部中断
//break;

//跳出单层循环
for(int x=0; x<10; x++) {
if(x == 3) {
break;
}
System.out.println("HelloWorld");
}

System.out.println("over");
System.out.println("-------------");

wc:for(int x=0; x<3; x++) {
nc:for(int y=0; y<4; y++) {
if(y == 2) {
//break nc;
break wc;
}
System.out.print("*");
}
System.out.println();
}
}
}
(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基础班
/*
continue:继续

使用场景:
循环中。离开此场景无意义。

测试,找到和break的区别:
break:跳出单层循环
continue:跳出一次循环,进入下一次的执行

练习题:
for(int x=1; x<=10; x++) {
if(x%3==0) {
//在此处填写代码
}
System.out.println(“Java基础班”);
}

我想在控制台输出2次:“Java基础班“
break;
我想在控制台输出7次:“Java基础班“
continue;
我想在控制台输出13次:“Java基础班“
System.out.println(“Java基础班”);




*/
class ContinueDemo {
public static void main(String[] args) {
for(int x=0; x<10; x++) {
if(x == 3) {
//break;
continue;
}

System.out.println(x);
}
}
}
(3)return:返回
A:用于结束方法的,后面还会在继续讲解和使用。
B:一旦遇到return,程序就不会在继续往后执行。
/*
return:返回

其实它的作用不是结束循环的,而是结束方法的。
*/
class ReturnDemo {
public static void main(String[] args) {
for(int x=0; x<10; x++) {
if(x == 2) {
System.out.println("退出");
//break;
//continue;
return;
}

System.out.println(x);
}

System.out.println("over");
}

}

你需要的是什么,直接评论留言。

获取更多资源加微信公众号“Java帮帮” (是公众号,不是微信好友哦)

还有“Java帮帮”今日头条号,技术文章与新闻,每日更新,欢迎阅读

学习交流请加Java帮帮交流QQ群553841695

分享是一种美德,分享更快乐!


网友评论

登录后评论
0/500
评论
奋斗蒙
+ 关注