• switch语句格式：

格式的解释：

switch:表示这是switch选择结构

表达式:这个地方的取值是有限定的

byte,short,int,char

JDK5以后可以是枚举

JDK7以后可以是字符串

case:后面跟的是要和表达式进行比较的值

语句体:要执行的代码

break:表示中断，结束的意思，可以控制switch语句的结束。

default:当所有的值都和表达式不匹配的时候，就执行default控制的语句。其实它就相当于if语句的else。

案例：

键盘录入一个数据，根据这个数据，我们输出对应的星期?

键盘录入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;

}

}

}

• 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”);

}

}

}

/*

需求：请在控制台输出数据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);

}

}

}

• 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++;

}

}

}

• 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);

}

}

• 循环嵌套

需求：在控制台输出九九乘法表。

首先我们写出九九乘法表：

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();

}

}

}

• 控制跳转语句：

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();

}

}

}

• 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);

}

}

}

• 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”);

}

}

• 例子:

需求：小芳的妈妈每天给她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++;

}

}

}