00 Java中的语句块
语句块(有时叫做复合语句)，是用花括号扩起的任意数量的简单Java语句。块确定了局部变量的作用域。块中的程序代码，作为一个整体，是要被一起执行的。块可以被嵌套在另一个块中，但是不能在两个嵌套的块内声明同名的变量。语句块可以使用外部的变量，而外部不能使用语句块中定义的变量，因为语句块中定义的变量作用域只限于语句块。
代码中的语句:
public class Test19 {
public static void main(String[] args) {
int n;
int a;
{
int k;
int n; //编译错误：不能重复定义变量n
} //变量k的作用域到此为止
}
}
每个方块就代表一个语句块,从中可以看出语句块的范围以及关系
01 Java中的方法
方法就是一段用来完成特定功能的代码片段，类似于其它语言的函数。
[修饰符1 修饰符2 …] 返回值类型 方法名(形式参数列表){
Java语句；… … …
}
方法用于定义该类或该类的实例的行为特征和功能实现。 方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。
方法的调用方式：
对象名.方法名(实参列表)
方法的详细说明
形式参数：在方法声明时用于接收外界传入的数据。
实参：调用方法时实际传给方法的数据。
返回值：方法在执行完毕后返还给调用它的环境的数据。
返回值类型：事先约定的返回值的数据类型，如无返回值，必须显示指定为为void。
方法的声明和调用
public class Test20 {
/** main方法：程序的入口 */
public static void main(String[] args) {
int num1 = 10;
int num2 = 20;
//调用求和的方法：将num1与num2的值传给add方法中的n1与n2
// 求完和后将结果返回，用sum接收结果
int sum = add(num1, num2);
System.out.println("sum = " + sum);//输出：sum = 30
//调用打印的方法：该方法没有返回值
print();
}
/** 求和的方法 */
public static int add(int n1, int n2) {
int sum = n1 + n2;
return sum;//使用return返回计算的结果
}
/** 打印的方法 */
public static void print() {
System.out.println("超超哥哥和java...");
}
}
注意事项
1. 实参的数目、数据类型和次序必须和所调用的方法声明的形式参数列表匹配。
2. return 语句终止方法的运行并指定要返回的数据。
3. Java中进行方法调用中传递参数时，遵循值传递的原则(传递的都是数据的副本)：
4. 基本类型传递的是该数据值的copy值。
5. 引用类型传递的是该对象引用的copy值，但指向的是同一个对象。
01.1 Java中方法的重载
方法的重载是指一个类中可以定义多个方法名相同，但参数不同的方法。调用时，会根据不同的参数自动匹配对应的方法。
雷区
重载的方法，实际是完全不同的方法，只是名称相同而已!
构成方法重载的条件：
1.不同的含义：形参类型、形参个数、形参顺序不同
2.只有返回值不同不构成方法的重载
如：
//返回值不同不构成重载
int a(String str){}与 void a(String str){}
//只有形参名称不同是不构成方法重载的
int a(String str){}与int a(String s){}
正确方法重载方式
public class Test21 {
public static void main(String[] args) {
System.out.println(add(3, 5));// 8
System.out.println(add(3, 5, 10));// 18
System.out.println(add(3.0, 5));// 8.0
System.out.println(add(3, 5.0));// 8.0
// 我们已经见过的方法的重载
System.out.println();// 0个参数
System.out.println(1);// 参数是1个int
System.out.println(3.0);// 参数是1个double
}
/** 求和的方法 */
public static int add(int n1, int n2) {
int sum = n1 + n2;
return sum;
}
// 方法名相同，参数个数不同，构成重载
public static int add(int n1, int n2, int n3) {
int sum = n1 + n2 + n3;
return sum;
}
// 方法名相同，参数类型不同，构成重载
public static double add(double n1, int n2) {
double sum = n1 + n2;
return sum;
}
// 方法名相同，参数顺序不同，构成重载
public static double add(int n1, double n2) {
double sum = n1 + n2;
return sum;
}
//编译错误：只有返回值不同，不构成方法的重载
public static double add(int n1, int n2) {
double sum = n1 + n2;
return sum;
}
//编译错误：只有参数名称不同，不构成方法的重载
public static int add(int n2, int n1) {
double sum = n1 + n2;
return sum;
}
}
02 Java中控制语句
流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。控制语句分为三类：顺序、选择和循环。
顺序结构
“顺序结构”代表“先执行a，再执行b”的逻辑。比如，先找个女朋友，再给女朋友打电话；先订婚，再结婚；
选择结构
“选择结构”代表“如果…，则…”的逻辑。比如，如果女朋友来电，则迅速接电话；如果看到红灯，则停车；
循环结构
“循环结构”代表“如果…，则再继续…”的逻辑。比如，如果没打通女朋友电话，则再继续打一次；如果没找到喜欢的人，则再继续找。
其实生活中的各种事情都可以用这几种结构来解释,编程的思想一定的顺从人类本身的思想,不会违反的来
03 Java中选择语句
选择结构用于判断给定的条件，然后根据判断的结果来控制程序的流程。
主要的选择结构有：if选择结构和switch多选择结构。有如下结构：
if单选择结构
if-else双选择结构
if-else if-else多选择结构
switch结构
03.1 Java选择语句中的if单结构
if(布尔表达式){
语句块
}
if语句对布尔表达式进行一次判定，若判定为真，则执行{}中的语句块，否则跳过该语句块。流程图如图所示:
配套练习:
public class Test1 {
public static void main(String[] args) {
//通过掷三个骰子看看今天的手气如何？
int i = (int)(6 * Math.random()) + 1;//通过Math.random()产生随机数
int j = (int)(6 * Math.random()) + 1;
int k = (int)(6 * Math.random()) + 1;
int count = i + j + k;
//如果三个骰子之和大于15，则手气不错
if(count > 15) {
System.out.println("今天手气不错");
}
//如果三个骰子之和在10到15之间，则手气一般
if(count >= 10 && count <= 15) { //错误写法：10<=count<=15
System.out.println("今天手气很一般");
}
//如果三个骰子之和小于10，则手气不怎么样
if(count < 10) {
System.out.println("今天手气不怎么样");
}
System.out.println("得了" + count + "分");
}
}
解读:Math类的使用
1.java.lang包中的Math类提供了一些用于数学计算的方法。
2.Math.random()该方法用于产生一个0到1区间的double类型的随机数，但是不包括1。
int i = (int) (6 * Math.random()); //产生：[0，5]之间的随机整数
注意点:
1.如果if语句不写{}，则只能作用于后面的第一条语句.所以强烈建议，任何时候都写上{}，即使里面只有一句话！
03.2 Java选择语句中的if-else双选择结构
if(布尔表达式){
语句块1
}else{
语句块2
}
当布尔表达式为真时，执行语句块1，否则，执行语句块2。也就是else部分。流程图如图所示。
配套练习:
public class Test3 {
public static void main(String[] args) {
int a=2;
int b=3;
if (a
System.out.println(a);
} else {
System.out.println(b);
}
}
}
日常我们使用的时候还会有下面这种使用方法:用条件运算符代替if-else
public class Test4 {
public static void main(String[] args) {
int a=2;
int b=3;
System.out.println((a
}
}
03.3 Java选择语句中的if-else if-else多选择结构
if(布尔表达式1) {
语句块1;
} else if(布尔表达式2) {
语句块2;
}……
else if(布尔表达式n){
语句块n;
} else {
语句块n+1;
}
当布尔表达式1为真时，执行语句块1;否则，判断布尔表达式2，当布尔表达式2为真时，执行语句块2;否则，继续判断布尔表达式3······;如果1~n个布尔表达式均判定为假时，则执行语句块n+1，也就是else部分。流程图如图所示。
根据个人的理解来看实际上就是 每次都做判断 比如做个性别分类:
一个人妖对其性别分类(下面是中文解释):
来了个人妖
if(是个男人?){
输出他是个男人 //这里显然不是,所以就跳到下面
} else if(是个女人?){
输出她是个女人 //这里显然不是,所以跳到下面语句块
}else{
他/她是个人妖 //这里就输出了结果
}
所以和if-else的结构来对比,就是每次不满足布尔表达式的时候,进入else的语句块后会再做判断而不是执行else后面的语句块
配套练习
public class Test5 {
public static void main(String[] args) {
int age = (int) (100 * Math.random());
System.out.print("年龄是" + age + "， 属于");
if (age < 15) {
System.out.println("儿童， 喜欢玩！");
} else if (age < 25) {
System.out.println("青年， 要学习！");
} else if (age < 45) {
System.out.println("中年， 要工作！");
} else if (age < 65) {
System.out.println("中老年， 要补钙！");
} else if (age < 85) {
System.out.println("老年， 多运动！");
} else {
System.out.println("老寿星， 古来稀！");
}
}
}
03.4 Java选择语句中的switch多选择结构
switch (表达式) {
case 值1:
语句序列1;
[break];
case 值2:
语句序列2;
[break];
… … … … …
[default:
默认语句;]
}
switch语句会根据表达式的值从相匹配的case标签处开始执行，一直执行到break语句处或者是switch语句的末尾。如果表达式的值与任一case值不匹配，则进入default语句(如果存在default语句的情况)。根据表达式值的不同可以执行许多不同的操作。switch语句中case标签在JDK1.5之前必须是整数(long类型除外)或者枚举，不能是字符串，在JDK1.7之后允许使用字符串(String)。
要注意，当布尔表达式是等值判断的情况，可以使用if-else if-else多选择结构或者switch结构，如果布尔表达式区间判断的情况，则只能使用if-else if-else多选择结构。
个人理解:实际上就是对号入座,比如这样说:
我的座位号是7
我就按照我的位置去逐排的去找,找到了,就坐下,找不到就坐备用席
switch (我的座位号是7) {
case 座位号1:
已经就坐到座位号1;
[break];
case 座位号2:
已经就坐到座位号2;
[break];
… … … … …
[default:
没有我的座位号,只好坐在备用的位置;]
}
配套练习
public class Test6 {
public static void main(String[] args) {
char c = 'a';
int rand = (int) (26 * Math.random());
char c2 = (char) (c + rand);
System.out.print(c2 + ": ");
switch (c2) {
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
System.out.println("元音");
break;
case 'y':
case 'w':
System.out.println("半元音");
break;
default:
System.out.println("辅音");
}
}
}
04 Java中循环结构
循环结构分两大类，一类是当型，一类是直到型。
当型：
当布尔表达式条件为true时，反复执行某语句，当布尔表达式的值为false时才停止循环，比如：while与for循环。
直到型：
先执行某语句， 再判断布尔表达式，如果为true，再执行某语句，如此反复，直到布尔表达式条件为false时才停止循环，比如do-while循环。
04.1 Java循环结构中的while循环
while (布尔表达式) {
循环体;
}
在循环刚开始时，会计算一次“布尔表达式”的值，若条件为真，执行循环体。而对于后来每一次额外的循环，都会在开始前重新计算一次。
语句中应有使循环趋向于结束的语句，否则会出现无限循环–––"死"循环。
配套练习:练习中的while(i<=100)就是结束条件
public class Test7 {
public static void main(String[] args) {
int i = 0;
int sum = 0;
// 1+2+3+…+100=?
while (i <= 100) {
sum += i;//相当于sum = sum+i;
i++;
}
System.out.println("Sum= " + sum);
}
}
04.2 Java循环结构中的do-while循环
do {
循环体;
} while(布尔表达式) ;
简单的来说就是先执行一次循环体,然后再做判断
do-while循环结构会先执行循环体，然后再判断布尔表达式的值，若条件为真，执行循环体，当条件为假时结束循环。do-while循环的循环体至少执行一次。do-while循环结构流程图如图所示。
配套练习
public class Test8 {
public static void main(String[] args) {
int i = 0;
int sum = 0;
do {
sum += i; // sum = sum + i
i++;
} while (i <= 100);//此处的；不能省略
System.out.println("Sum= " + sum);
}
}
延伸扩展
while 和do-while的区别
浓缩成一句话来说就是又没有先执行语句块,
while:没有先执行语句块,因为是先判断后再根据条件看是否执行
do-while:先执行语句块,不管满足不满足do-while都会至少执行一次语句块
public class Test9 {
public static void main(String[] args) {
//while循环：先判断再执行
int a = 0;
while (a < 0) {
System.out.println(a);
a++;
}
System.out.println("-----");
//do-while循环：先执行再判断
a = 0;
do {
System.out.println(a);
a++;
} while (a < 0);
}
}
4.3 Java循环结构中的for循环
for (初始表达式; 布尔表达式; 迭代因子) {
循环体;
}
for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。for循环在第一次反复之前要进行初始化，即执行初始表达式;随后，对布尔表达式进行判定，若判定结果为true，则执行循环体，否则，终止循环;最后在每一次反复的时候，进行某种形式的“步进”，即执行迭代因子。
A. 初始化部分设置循环变量的初值
B. 条件判断部分为任意布尔表达式
C. 迭代因子控制循环变量的增减
for循环在执行条件判定后，先执行的循环体部分，再执行步进。
for循环结构的流程图如图3-18所示。
配套练习
public class Test10 {
public static void main(String args[]) {
int sum = 0;
//1.求1-100之间的累加和
for (int i = 0; i <= 100; i++) {
sum += i;
}
System.out.println("Sum= " + sum);
//2.循环输出9-1之间的数
for(int i=9;i>0;i--){
System.out.print(i+"、");
}
System.out.println();
//3.输出90-1之间能被3整除的数
for(int i=90;i>0;i-=3){
System.out.print(i+"、");
}
System.out.println();
}
}
04.4 Java循环结构中的嵌套循环
在一个循环语句内部再嵌套一个或多个循环，称为嵌套循环。while、do-while与for循环可以任意嵌套多层
配套代码
public class Test15 {
public static void main(String args[]) {
for (int i = 1; i < 10; i++) { // i是一个乘数
for (int j = 1; j <= i; j++) { // j是另一个乘数
System.out.print(j + "*" + i + "=" + (i * j < 10 ? (" " + i * j) : i * j) + " ");
}
System.out.println();
}
}
}
上面是一个九九乘法表
很多人再看这个的时候一般都会乱,主要是不理解其中的逻辑
实际上就是外面第一层for执行后就在执行内部的for语句,知道内部的for语句不在执行了,再进行外面的for语句 之后的内容就重复执行,知道外部的for语句不再进行执行技巧: 如果不能理解的话可以去bil上搜索java断点 通过这种方式可以很直观的看到程序运行的顺序,也可以帮助大家更快的理解其中的运行原理.
04.5 Java循环结构中的break语句和continue语句
break
在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。
continue
continue 语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。(
continue用在while，do-while中，continue 语句立刻跳到循环首部，越过了当前循环的其余部分。
continue用在for循环中，跳到for循环的迭代因子部分。)
配套解释-break
public class Test16 {
public static void main(String[] args) {
int total = 0;//定义计数器
System.out.println("Begin");
while (true) {
total++;//每循环一次计数器加1
int i = (int) Math.round(100 * Math.random());
//当i等于88时，退出循环
if (i == 88) {
break;
}
}
//输出循环的次数
System.out.println("Game over， used " + total + " times.");
}
}
配套解释-continue
public class Test17 {
public static void main(String[] args) {
int count = 0;//定义计数器
for (int i = 100; i < 150; i++) {
//如果是3的倍数，则跳过本次循环，继续进行下一次循环
if (i % 3 == 0){
continue;
}
//否则(不是3的倍数)，输出该数
System.out.print(i + "、");
count++;//没输出一个数，计数器加1
//根据计数器判断每行是否已经输出了5个数
if (count % 5 == 0) {
System.out.println();
}
}
}
}
## 00 Java中的语句块
语句块(有时叫做复合语句)，是用花括号扩起的任意数量的简单Java语句。块确定了局部变量的作用域。块中的程序代码，作为一个整体，是要被一起执行的。块可以被嵌套在另一个块中，但是不能在两个嵌套的块内声明同名的变量。语句块可以使用外部的变量，而外部不能使用语句块中定义的变量，因为语句块中定义的变量作用域只限于语句块。
**代码中的语句:**
```javapublic class Test19 { public static void main(String[] args) { int n; int a; { int k; int n; //编译错误：不能重复定义变量n } //变量k的作用域到此为止 }}```每个方块就代表一个语句块,从中可以看出语句块的范围以及关系
## 01 Java中的方法
方法就是一段用来完成特定功能的代码片段，类似于其它语言的函数。
```java[修饰符1 修饰符2 …] 返回值类型 方法名(形式参数列表){ Java语句；… … … }``` 方法用于定义该类或该类的实例的行为特征和功能实现。 方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。
方法的调用方式：
对象名.方法名(实参列表)
方法的详细说明
1. 形式参数：在方法声明时用于接收外界传入的数据。
2. 实参：调用方法时实际传给方法的数据。
3. 返回值：方法在执行完毕后返还给调用它的环境的数据。
4. 返回值类型：事先约定的返回值的数据类型，如无返回值，必须显示指定为为void。
**方法的声明和调用**
```javapublic class Test20 { /** main方法：程序的入口 */ public static void main(String[] args) { int num1 = 10; int num2 = 20; //调用求和的方法：将num1与num2的值传给add方法中的n1与n2 // 求完和后将结果返回，用sum接收结果 int sum = add(num1, num2); System.out.println("sum = " + sum);//输出：sum = 30 //调用打印的方法：该方法没有返回值 print(); } /** 求和的方法 */ public static int add(int n1, int n2) { int sum = n1 + n2; return sum;//使用return返回计算的结果 } /** 打印的方法 */ public static void print() { System.out.println("超超哥哥和java..."); }}```
**注意事项**
1. 实参的数目、数据类型和次序必须和所调用的方法声明的形式参数列表匹配。
2. return 语句终止方法的运行并指定要返回的数据。
3. Java中进行方法调用中传递参数时，遵循值传递的原则(传递的都是数据的副本)：
4. 基本类型传递的是该数据值的copy值。
5. 引用类型传递的是该对象引用的copy值，但指向的是同一个对象。
## 01.1 Java中方法的重载
方法的重载是指一个类中可以定义多个方法名相同，但参数不同的方法。调用时，会根据不同的参数自动匹配对应的方法。
**雷区**
重载的方法，实际是完全不同的方法，只是名称相同而已!
构成方法重载的条件：
1.不同的含义：形参类型、形参个数、形参顺序不同
2.只有返回值不同不构成方法的重载
如：
```java//返回值不同不构成重载int a(String str){}与 void a(String str){} //只有形参名称不同是不构成方法重载的int a(String str){}与int a(String s){}
```**正确方法重载方式**```javapublic class Test21 { public static void main(String[] args) { System.out.println(add(3, 5));// 8 System.out.println(add(3, 5, 10));// 18 System.out.println(add(3.0, 5));// 8.0 System.out.println(add(3, 5.0));// 8.0 // 我们已经见过的方法的重载 System.out.println();// 0个参数 System.out.println(1);// 参数是1个int System.out.println(3.0);// 参数是1个double } /** 求和的方法 */ public static int add(int n1, int n2) { int sum = n1 + n2; return sum; } // 方法名相同，参数个数不同，构成重载 public static int add(int n1, int n2, int n3) { int sum = n1 + n2 + n3; return sum; } // 方法名相同，参数类型不同，构成重载 public static double add(double n1, int n2) { double sum = n1 + n2; return sum; } // 方法名相同，参数顺序不同，构成重载 public static double add(int n1, double n2) { double sum = n1 + n2; return sum; } //编译错误：只有返回值不同，不构成方法的重载 public static double add(int n1, int n2) { double sum = n1 + n2; return sum; } //编译错误：只有参数名称不同，不构成方法的重载 public static int add(int n2, int n1) { double sum = n1 + n2; return sum; } }```
## 02 Java中控制语句
流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。控制语句分为三类：顺序、选择和循环。
**顺序结构**
“顺序结构”代表“先执行a，再执行b”的逻辑。比如，先找个女朋友，再给女朋友打电话；先订婚，再结婚；
**选择结构**
“选择结构”代表“如果…，则…”的逻辑。比如，如果女朋友来电，则迅速接电话；如果看到红灯，则停车；
**循环结构**
“循环结构”代表“如果…，则再继续…”的逻辑。比如，如果没打通女朋友电话，则再继续打一次；如果没找到喜欢的人，则再继续找。
其实生活中的各种事情都可以用这几种结构来解释,编程的思想一定的顺从人类本身的思想,不会违反的来
## 03 Java中选择语句
选择结构用于判断给定的条件，然后根据判断的结果来控制程序的流程。
主要的选择结构有：if选择结构和switch多选择结构。有如下结构：
- if单选择结构 - if-else双选择结构 - if-else if-else多选择结构 - switch结构
## 03.1 Java选择语句中的if单结构
```javaif(布尔表达式){语句块}```
if语句对布尔表达式进行一次判定，若判定为真，则执行{}中的语句块，否则跳过该语句块。流程图如图所示:
**配套练习:**
```javapublic class Test1 { public static void main(String[] args) { //通过掷三个骰子看看今天的手气如何？ int i = (int)(6 * Math.random()) + 1;//通过Math.random()产生随机数 int j = (int)(6 * Math.random()) + 1; int k = (int)(6 * Math.random()) + 1; int count = i + j + k; //如果三个骰子之和大于15，则手气不错 if(count > 15) { System.out.println("今天手气不错"); } //如果三个骰子之和在10到15之间，则手气一般 if(count >= 10 && count <= 15) { //错误写法：10<=count<=15 System.out.println("今天手气很一般"); } //如果三个骰子之和小于10，则手气不怎么样 if(count < 10) { System.out.println("今天手气不怎么样"); } System.out.println("得了" + count + "分"); }}```
**解读:Math类的使用**
1.java.lang包中的Math类提供了一些用于数学计算的方法。
2.Math.random()该方法用于产生一个0到1区间的double类型的随机数，但是不包括1。
int i = (int) (6 * Math.random()); //产生：[0，5]之间的随机整数
**注意点:**
1.如果if语句不写{}，则只能作用于后面的第一条语句.所以强烈建议，任何时候都写上{}，即使里面只有一句话！
## 03.2 Java选择语句中的if-else双选择结构
```javaif(布尔表达式){ 语句块1}else{ 语句块2}```
当布尔表达式为真时，执行语句块1，否则，执行语句块2。也就是else部分。流程图如图所示。
**配套练习:**
```javapublic class Test3 { public static void main(String[] args) { int a=2; int b=3; if (a
**日常我们使用的时候还会有下面这种使用方法:用条件运算符代替if-else**
```javapublic class Test4 { public static void main(String[] args) { int a=2; int b=3; System.out.println((a
## 03.3 Java选择语句中的if-else if-else多选择结构
```javaif(布尔表达式1) {语句块1;} else if(布尔表达式2) {语句块2;}……else if(布尔表达式n){ 语句块n;} else { 语句块n+1;}```
当布尔表达式1为真时，执行语句块1;否则，判断布尔表达式2，当布尔表达式2为真时，执行语句块2;否则，继续判断布尔表达式3······;如果1~n个布尔表达式均判定为假时，则执行语句块n+1，也就是else部分。流程图如图所示。
根据个人的理解来看实际上就是 每次都做判断 比如做个性别分类:
一个人妖对其性别分类(下面是中文解释):
```java来了个人妖if(是个男人?){ 输出他是个男人 //这里显然不是,所以就跳到下面} else if(是个女人?){ 输出她是个女人 //这里显然不是,所以跳到下面语句块}else{ 他/她是个人妖 //这里就输出了结果}```
所以和if-else的结构来对比,就是每次不满足布尔表达式的时候,进入else的语句块后会再做判断而不是执行else后面的语句块
**配套练习**
```javapublic class Test5 { public static void main(String[] args) { int age = (int) (100 * Math.random()); System.out.print("年龄是" + age + "， 属于"); if (age < 15) { System.out.println("儿童， 喜欢玩！"); } else if (age < 25) { System.out.println("青年， 要学习！"); } else if (age < 45) { System.out.println("中年， 要工作！"); } else if (age < 65) { System.out.println("中老年， 要补钙！"); } else if (age < 85) { System.out.println("老年， 多运动！"); } else { System.out.println("老寿星， 古来稀！"); } }}```
## 03.4 Java选择语句中的switch多选择结构
```javaswitch (表达式) {case 值1: 语句序列1;[break];case 值2: 语句序列2;[break]; … … … … …[default: 默认语句;]}```
switch语句会根据表达式的值从相匹配的case标签处开始执行，一直执行到break语句处或者是switch语句的末尾。如果表达式的值与任一case值不匹配，则进入default语句(如果存在default语句的情况)。根据表达式值的不同可以执行许多不同的操作。switch语句中case标签在JDK1.5之前必须是整数(long类型除外)或者枚举，不能是字符串，在JDK1.7之后允许使用字符串(String)。
要注意，当布尔表达式是等值判断的情况，可以使用if-else if-else多选择结构或者switch结构，如果布尔表达式区间判断的情况，则只能使用if-else if-else多选择结构。
个人理解:实际上就是对号入座,比如这样说:
我的座位号是7
我就按照我的位置去逐排的去找,找到了,就坐下,找不到就坐备用席
```javaswitch (我的座位号是7) {case 座位号1: 已经就坐到座位号1;[break];case 座位号2: 已经就坐到座位号2;[break]; … … … … …[default: 没有我的座位号,只好坐在备用的位置;]}```
**配套练习**
```javapublic class Test6 { public static void main(String[] args) { char c = 'a'; int rand = (int) (26 * Math.random()); char c2 = (char) (c + rand); System.out.print(c2 + ": "); switch (c2) { case 'a': case 'e': case 'i': case 'o': case 'u': System.out.println("元音"); break; case 'y': case 'w': System.out.println("半元音"); break; default: System.out.println("辅音"); } }}```
## 04 Java中循环结构
循环结构分两大类，一类是当型，一类是直到型。
**当型：**
当布尔表达式条件为true时，反复执行某语句，当布尔表达式的值为false时才停止循环，比如：while与for循环。
**直到型：**
先执行某语句， 再判断布尔表达式，如果为true，再执行某语句，如此反复，直到布尔表达式条件为false时才停止循环，比如do-while循环。
## 04.1 Java循环结构中的while循环
```javawhile (布尔表达式) { 循环体;}```
在循环刚开始时，会计算一次“布尔表达式”的值，若条件为真，执行循环体。而对于后来每一次额外的循环，都会在开始前重新计算一次。
语句中应有使循环趋向于结束的语句，否则会出现无限循环–––"死"循环。
**配套练习:练习中的while(i<=100)就是结束条件**
```javapublic class Test7 { public static void main(String[] args) { int i = 0; int sum = 0; // 1+2+3+…+100=? while (i <= 100) { sum += i;//相当于sum = sum+i; i++; } System.out.println("Sum= " + sum); }}```
## 04.2 Java循环结构中的do-while循环
```javado { 循环体; } while(布尔表达式) ;```
简单的来说就是先执行一次循环体,然后再做判断
do-while循环结构会先执行循环体，然后再判断布尔表达式的值，若条件为真，执行循环体，当条件为假时结束循环。do-while循环的循环体至少执行一次。do-while循环结构流程图如图所示。
**配套练习**
```javapublic class Test8 { public static void main(String[] args) { int i = 0; int sum = 0; do { sum += i; // sum = sum + i i++; } while (i <= 100);//此处的；不能省略 System.out.println("Sum= " + sum); }}```
**延伸扩展**
while 和do-while的区别
浓缩成一句话来说就是又没有先执行语句块,
while:没有先执行语句块,因为是先判断后再根据条件看是否执行
do-while:先执行语句块,不管满足不满足do-while都会至少执行一次语句块
```javapublic class Test9 { public static void main(String[] args) { //while循环：先判断再执行 int a = 0; while (a < 0) { System.out.println(a); a++; } System.out.println("-----"); //do-while循环：先执行再判断 a = 0; do { System.out.println(a); a++; } while (a < 0); }}```
## 4.3 Java循环结构中的for循环
```javafor (初始表达式; 布尔表达式; 迭代因子) { 循环体;}```
for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。for循环在第一次反复之前要进行初始化，即执行初始表达式;随后，对布尔表达式进行判定，若判定结果为true，则执行循环体，否则，终止循环;最后在每一次反复的时候，进行某种形式的“步进”，即执行迭代因子。
A. 初始化部分设置循环变量的初值
B. 条件判断部分为任意布尔表达式
C. 迭代因子控制循环变量的增减
for循环在执行条件判定后，先执行的循环体部分，再执行步进。
for循环结构的流程图如图3-18所示。
**配套练习**
```javapublic class Test10 { public static void main(String args[]) { int sum = 0; //1.求1-100之间的累加和 for (int i = 0; i <= 100; i++) { sum += i; } System.out.println("Sum= " + sum); //2.循环输出9-1之间的数 for(int i=9;i>0;i--){ System.out.print(i+"、"); } System.out.println(); //3.输出90-1之间能被3整除的数 for(int i=90;i>0;i-=3){ System.out.print(i+"、"); } System.out.println(); }}```
## 04.4 Java循环结构中的嵌套循环
在一个循环语句内部再嵌套一个或多个循环，称为嵌套循环。while、do-while与for循环可以任意嵌套多层
配套代码
```javapublic class Test15 { public static void main(String args[]) { for (int i = 1; i < 10; i++) { // i是一个乘数 for (int j = 1; j <= i; j++) { // j是另一个乘数 System.out.print(j + "*" + i + "=" + (i * j < 10 ? (" " + i * j) : i * j) + " "); } System.out.println(); } }}```
上面是一个九九乘法表
很多人再看这个的时候一般都会乱,主要是不理解其中的逻辑
实际上就是外面第一层for执行后就在执行内部的for语句,知道内部的for语句不在执行了,再进行外面的for语句 **之后的内容就重复执行,知道外部的for语句不再进行执行技巧: 如果不能理解的话可以去bil上搜索java断点 通过这种方式可以很直观的看到程序运行的顺序,也可以帮助大家更快的理解其中的运行原理.**
## 04.5 Java循环结构中的break语句和continue语句
**break**
在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。
**continue**
continue 语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。(
1. continue用在while，do-while中，continue 语句立刻跳到循环首部，越过了当前循环的其余部分。
2. continue用在for循环中，跳到for循环的迭代因子部分。)
**配套解释-break**
```javapublic class Test16 { public static void main(String[] args) { int total = 0;//定义计数器 System.out.println("Begin"); while (true) { total++;//每循环一次计数器加1 int i = (int) Math.round(100 * Math.random()); //当i等于88时，退出循环 if (i == 88) { break; } } //输出循环的次数 System.out.println("Game over， used " + total + " times."); }}```
**配套解释-continue**
```javapublic class Test17 { public static void main(String[] args) { int count = 0;//定义计数器 for (int i = 100; i < 150; i++) { //如果是3的倍数，则跳过本次循环，继续进行下一次循环 if (i % 3 == 0){ continue; } //否则(不是3的倍数)，输出该数 System.out.print(i + "、"); count++;//没输出一个数，计数器加1 //根据计数器判断每行是否已经输出了5个数 if (count % 5 == 0) { System.out.println(); } } }}```
扫一扫
648
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
