java任务三
流程控制语句的分类：流程控制可以分为三类
- 顺序控制语句
- 分支控制语句（有if和swich两个结构哦）
- 循环控制语句（有for、while、do……while三个结构）
顺序结构
- 定义：按照代码的先后顺序，依次执行，就是一条语句执行完执行下一条语句，程序中大多数的代码都是这样执行的。
- 结构就是：
语句1；
语句2；
……
语句n；
分支语句
分支if语句
分支if语句包括三种
- if语句格式1：
if (关系表达式) {
语句体;
}
语句1;程序怎么走（即怎么执行）：
①首先计算关系表达式的值。
②如果关系表达式的值为true就执行语句体
③如果关系表达式的值为false就不执行语句体
④但是后面的语句1是一定会执行的
流程图为：
- if语句的格式2：
if (关系表达式) {
语句体1;
} else {
语句体2;
}
语句1;程序怎么走（即怎么执行）：
①首先计算关系表达式的值
②如果关系表达式的值为true就执行语句体1
③如果关系表达式的值为false就执行语句体2
④继续执行后面的语句内容，即语句1是一定会执行的。
流程图为：
- if语句的格式3：
if (关系表达式1) {
语句体1;
} else if (关系表达式2) {
语句体2;
}
…
else {
语句体n+1;
}程序怎么走（即怎么执行）：
①首先计算关系表达式1的值
②如果值为true就执行语句体1；如果值为false就不执行语句体1，然后去计算关系表达式2的值
③如果值为true就执行语句体2；如果值为false就不执行语句体2，然后去计算关系表达式3的值
④…
⑤如果前面的都为false，就执行语句体n+1。
流程图为：
注意点
一个程序写好要去进行数据测试，数据测试一般测试几个正确数据，测试几个边界数据，测试一些错误数据
分支结构switch
- switch语句的格式
switch (表达式) {
case 1:
语句体1;
break;
case 2:
语句体2;
break;
...
default:
语句体n+1;
break;
}- 这里switch这个语句的一些格式说明：
- 这里的表达式的值可以为byte、short、int、char（注意long不行的，只能是int一下范围的整数数据类型），JDK5以后可以是“枚举”，JDK7以后可以是String。
- ”case+空格+一个值：“，这个值是要和表达式进行比较的，要比较是否相等。相等才执行”case+空格+一个值：“后面的语句，遇到break退出，要是没有遇到break，就执行到下一个case的语句了，那就直接运行那个case下的语句，不用比较case后面的值是否与表达式一样了。case相当与switch语句的入口，break相当于switch语句的出口。
- break：表示中断，结束的意思，用来结束switch语句。
- default：表示前面所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。（注意default后面是直接跟冒号的，注意格式）
package network;
import java.util.Scanner;
public class A {
public static void main(String[] args) {
int l=45;
switch(l) {
case 1:
break;
case 2:
System.out.println("abc");
break;
// case 2://不能同时出现两个一样的case。
// break;
default:
System.out.println("12");
case 45:
System.out.println("23");
break;
}
//上面的结果还是输出23，所以可以看出，程序是跳着执行的，想找有没有匹配的值，再去看default的，上面不会因为default在case 45之前，就先执行default。
}
}要是最后一个case没有break，他也是会自动退出switch的。就算他不是default。
package network;
import java.util.Scanner;
public class A {
public static void main(String[] args) {
int l=45;
switch(l) {
case 1:
case 2:
System.out.println("abc");
break;
case 45:
System.out.println("23");
}
System.out.println("hello");
}
}
//输出结果是：
23
hello- switch是怎么走的（即怎么执行的，执行流程）
执行流程：
- 首先计算出表达式的值
- 其次，和case依次比较，一旦有对应的值，就会直接跳到相应case的语句去执行，在执行的过程中，遇到break就会结束。要是这个case结束还没有碰到break，就执行下一个case下面的语句，不用与他进行比较。一直到向下顺序执行，直到碰到break或执行到switch结束的“}”。要是向下执行碰到default，也会进去执行，且，要是default没有break，他还是会向下执行，并不会从default这里直接跳出switch循环。而是直接执行default下面case。要是default在switch的最后，那么他就会自动退出switch，因为switch的语句执行完了嘛，所以，就是会跳出来的。然后解释一下为什么说default的break是可选的，因为default习惯上是在最后的，所以不写break他也跳出switch了。
package network;
import java.util.Scanner;
public class A {
public static void main(String[] args) {
int l=2;
switch(l) {
case 1:
case 2:
System.out.println("abc");
default:
System.out.println("猜想正确");
case 45:
System.out.println("23");
}
System.out.println("hello");
}
}
结果是输出：
abc
猜想正确
23
hello还有一个例子就是，你没有匹配到对应的case的值，去执行default，但是default不在最后且没有break，default后面还有case的话，那个case还是会执行的，就算一开始没有匹配到45，结果还是执行到了case 45下的语句
package network;
import java.util.Scanner;
public class A {
public static void main(String[] args) {
int l=4;
switch(l) {
case 1:
case 2:
System.out.println("abc");
default:
System.out.println("猜想正确");
case 45:
System.out.println("23");
}
System.out.println("hello");
}
}
结果输出：
猜想正确
23
hello- 最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
总之，switch的重点就是（上面的switch不用看，只看这个就行）：
- 表达式的值只能是那么几个（不大于int的整数，枚举，字符串）
- 他是跳着匹配的且要是没有匹配到就执行default，与顺序无关
- break跳出，和执行完都可以跳出
- 要是没有遇到break，他就继续向下执行下一个case或default，且default执行完也没有遇到break，也继续向下执行，一直到break或运行出switch。
- 流程图
- case穿透现象：在switch语句中，如果case控制的语句体后面不写break，将出现穿透现象，在不判断下一个case值的情况下，向下运行， 直到遇到break，或者整体switch语句结束
利用case穿透可以做一些事情如：
需求：一年有12个月，分属于春夏秋冬4个季节，键盘录入一个月份，请用程序实现判断该月份属于哪个季节，并输出。
public class Demo1 {
public static void main(String[] args) {
//键盘录入月份数据，使用变量接收
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个月份：");
int month = sc.nextInt();
//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("你输入的月份有误");
}
}
}运行结果：
春：3、4、5
夏：6、7、8
秋：9、10、11
冬：1、2、12循环语句
循环体语句：循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句。
值得注意的是：当反复 执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。
循环结构都是有四部分组成的
- 初始化语句： 用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样
- 条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去
- 循环体语句： 用于表示循环反复执行的内容，简单说就是循环反复执行的事情
- 条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去
for循环语句
- for循环格式
for (初始化语句;条件判断语句;条件控制语句) {
循环体语句;
}- for语句的执行顺序
①执行初始化语句
②执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
③执行循环体语句
④执行条件控制语句
⑤回到②继续
for (A;B;C) {
D;
}
E;
比如
A是初始化语句
B是条件判断语句
C是条件控制语句
D是循环体语句
E是其他语句
那他的执行顺序是：A B D C B D C B然后B要是判断为false，就执行E- 应用
比如：在控制台输出1-5数据
public class ForTest01 {
public static void main(String[] args) {
//需求：输出数据1-5
for(int i=1; i<=5; i++) {
System.out.println(i);
}
}
}结果
1
2
3
4
5运行结束后i为6
注意：如果题目外面要用到某个变量，比如求和，那么求和变量的定义位置，必须在循环外部，如果定义在在循环内部则计算出的数据将是错误的。
如下图，这个变量定义在for的{}内，所以他出了for就离开了他的作用域了
- for语句的流程图
- 例子：统计“水仙花数”一共有多少个，并在控制台输出个数
示例代码：
public class ForTest05 {
public static void main(String[] args) {
//定义变量count，用于保存“水仙花数”的数量，初始值为0
int count = 0;
//输出所有的水仙花数必然要使用到循环，遍历所有的三位数，三位数从100开始，到999结束
for(int i=100; i<1000; i++) {
//在计算之前获取三位数中每个位上的值
int ge = i%10;
int shi = i/10%10;
int bai = i/10/10%10;
//在判定水仙花数的过程中，满足条件不再输出，更改为修改count的值，使count+1
if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
count++;
}
}
//打印输出最终结果
System.out.println("水仙花共有：" + count + "个");
}
}- 本题要点1：
- 今后如果需求带有统计xxx，请先想到计数器变量。就是count，习惯上我们都用这个变量来计数。
- 计数器变量定义的位置，必须在循环外部
- 本题要点二：
- 取个位的技巧用%，比如：4212要取个位，则，int i=4212%10；
- 取开头的1位或几位，用/，因为两边都是整数，所以这个/就是整除。比如要取4212的最高位则int i=1412/1000;比如要取4212的最高两位则int i=4212/100；
- 比如要取中间的那个1怎么取？int i=4212/10。把这个1移到个位上，然后取个位，int j=i % 10；
比如要取很多位的中间一位，那也是同理：123456789 先整除10000得到12345 ，再对10取余得到5
但是上面都对以知道数取其中的一个数，或者是已知数的位数，取他的第几位。
while循环
- while循环的完整结构
初始化语句;
while (条件判断语句) {
循环体语句;
条件控制语句;
}- while循环执行流程：
①执行初始化语句
②执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
③执行循环体语句
④执行条件控制语句
⑤回到②继续 - 流程图一看就可以知道执行顺序了
- 例子：
package network;
public class A {
public static void main(String[] args) {
//需求：在控制台输出5次"HelloWorld和一个数字"
//while循环实现
int j = 1;
while(j<=5) {
System.out.println("HelloWorld"+j);
j++;
}
}
}运行结果：
HelloWorld1
HelloWorld2
HelloWorld3
HelloWorld4
HelloWorld5do……while循环
- do……while语句的完整格式：
初始化语句;
do {
循环体语句;
条件控制语句;
}while(条件判断语句);- 执行流程
执行流程：
① 执行初始化语句
② 执行循环体语句
③ 执行条件控制语句
④ 执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
⑤ 回到②继续 - 例子
public class DoWhileDemo {
public static void main(String[] args) {
//需求：在控制台输出5次"HelloWorld"
//for循环实现
for(int i=1; i<=5; i++) {
System.out.println("HelloWorld");
}
System.out.println("--------");
//do...while循环实现
int j = 1;
do {
System.out.println("HelloWorld");
j++;
}while(j<=5);
}
}- 流程图
- 三种循环语句的区别
do……while与for循环、while循环的区别：
- for循环和while循环先判断条件是否成立，然后决定是否执行循环体（即先判断后执行）
- do…while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后判断）
for、while、do……while的使用上的区别：
- for语句适合知道循环次数的循环,while和do……while适合不知道循环次数但是知道循环结束条件的循环
- while适合先判断再执行循环体的循环，do……while适合至少执行一次循环体的循环。
这三个循环语句的死循环（无限循环）格式
- for(;😉{}
- while(true){}
- do {} while(true);
还有就是比如像for循环一般这么定义for（int i；i<10;i++）{……}的i这样定义在for的（）里面，那么这个变量i的作用域就是在for循环的{}中，但是while循环，一般while的那个循环控制语句的那个变量是定义在while循环外面的，所以在while块外面也是可以访问的。但是如果for循环的循环初始化语句定义了空，反正就是那个访问的变量定义在for的外面，那么在for里面可以访问（因为小块是可以访问大块的内容的嘛），且在for循环外面也是可以访问的，因为这个z是定义在main中的，且第17行的访问z的那个语句也是在main下的，他们是属于同一个块内，所以可以访问。如图
还有就是java不想c语言，小块内的变量可以覆盖大块内的变量，如下图
但是方法中，几个同级别的方法。比如下面这样是可以的，他们没有大块包小块。
且这样也是可以的
跳转控制语句
即continue和break。
- continue和break都是用在循环（三种循环都可以用）中的，并且一般是基于条件控制的，即一般是有if（）{}，然后continue和break就放在if的{}里面。（break也可能在switch等上面出现，但是continue就只能在循环中使用了）
- continue是执行到这个continue，这一轮循环，continue下面的语句都不执行了，直接开始下一轮循环
- break是执行到break，那这个break所在的那个循环就结束了（即如果有多层循环嵌套，break在里面的for循环内，那执行到break是退出里面的那一层for循环）
- 例子：
package network;
public class A {
public static void main(String[] args) {
for(int i=0;i<5;i++) {
if(i%2==1) {
continue;
}
System.out.println(i);
}
}
}
结果输出：
0
2
4例子：
package network;
public class A {
public static void main(String[] args) {
for(int i=0;i<5;i++) {
if(i==3) {
break;
}
System.out.println(i);
}
}
}
结果输出：
0
1
2例子：
package network;
public class A {
public static void main(String[] args) {
for(int i=0;i<5;i++) {
for(int j=20;j<23;j++) {
if(i==3) {
break;
}
System.out.println(i+"and"+j);
}
}
}
}
结果输出：
0and20
0and21
0and22
1and20
1and21
1and22
2and20
2and21
2and22
4and20
4and21
4and22循环嵌套
注意理解一句话：就是if（）{………………}和for（）{………………}和while（）{…………}和do{……}while（）；和switch（）{…………}等这这个结构就相当于一句话（上面的这些语句，只有do……while是后面有；的,其他都是以 } 结尾的没有；）
- 嵌套就是，一个语句里面有另一个语句。比如
if(){
if(){
}
}//这就是if的嵌套
for(){
for(){
}
}//这就是for的嵌套。你可以理解为，里面的那个for循环就是相当于一句语句而已
//就想象是这个
for(){
System.out.println("");//这个语句和for语句一样呀，都是一句话嘛。所以有什么难理解的呢
}- 嵌套循环怎么走（怎么执行，执行流程）
我们看一个例子就知道了
public static void main(String[] args) {
//外循环控制小时的范围，内循环控制分钟的范围
for (int hour = 0; hour < 24; hour++) {
for (int minute = 0; minute < 60; minute++) {
System.out.println(hour + "时" + minute + "分");
}
System.out.println("--------");
}
}
//执行的过程就是这样
hour=0 hour=1 …………………… hour=23
minute=0， minute=0， minute=0，
minute=1， minute=1， minute=1，
minute=2， minute=2， minute=2，
…… …… ……
minute=59， minute=59， minute=59，Random类
- 概述：Random类似Scanner，也是Java提供好的API，内部提供了产生随机数的功能。就是一个封装好的类，相当于一种工具的类。这个类里面有提供随机数的方法。
- 使用步骤：
- 导入包
import java.util.Random; - 创建对象
Random r = new Random(); - 产生随机数
int num = r.nextInt(10);
//这个Random的这个nextInt（10）方法的作用是：产生一个[0，10）的随机数，且是整数。所以就是产生一个 [ 0,9 ] 的随机整数。
- Random的方法：
现在我们就用到nextInt（int i）这个方法。作用是：产生一个[0，10）的随机整数 - 例子
import java.util.Random;
public class RandomDemo {
public static void main(String[] args) {
//创建对象
Random r = new Random();
//用循环获取10个随机数
for(int i=0; i<10; i++) {
//获取随机数
int number = r.nextInt(10);
System.out.println("number:" + number);
}
//需求：获取一个1-100之间的随机数
int x = r.nextInt(100) + 1;
System.out.println(x);
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
