从零开始的Java笔记（day6——流程控制）
本次笔记的重点
流程控制
流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。
分类：控制语句分为三类——顺序控制结构、选择控制结构和循环控制结构。
顺序结构
顺序结构的程序设计是最简单的，只要按照解决问题的顺序写出相应的语句就行，它的执行顺序是自上而下，依次执行。
例如：例如计算圆的面积，其程序的语句顺序就是输入圆的半径r，计算s = 3.14159rr,输出圆的面积s。
不过大多数情况下顺序结构都是作为程序的一部分，与其它结构一起构成一个复杂的程序，例如分支结构中的复合语句、循环结构中的循环体等。下面会进行详细介绍：
分支结构(选择结构)
if分支
if(布尔表达式){
语句块
}
if语句对布尔表达式进行一次判定，若判定为真，则执行{}中的语句块，否则跳过该语句块。流程图如图所示：
练习：
public class TestIf01{
public static void main(String[] args){
//实现一个功能：给出三个数，对三个数求和计算，根据和的大小来分配不同的奖品
//1.给出三个数：
int num1 = 6;
int num2 = 2;
int num3 = 3;
//2.求和
int sum = 0;
sum += num1;
sum += num2;
sum += num3;
System.out.println("和为："+sum);
//3.根据和判断奖品：
//如果和大于等于14，那么就是一等奖
if(sum>=14){
System.out.println("一等奖");
System.out.println("恭喜你很幸运，中了一等奖");
}
if(sum>=10&&sum<14){
System.out.println("二等奖");
}
if(sum>=6&&sum<10){
System.out.println("三等奖");
}
if(sum<6){
System.out.println("四等奖");
}
}
}
if-单分支：
（1）结构：
if(条件表达式，这个表达式的结果是布尔值：要么是false，要么是true){
如果上面()中的表达式返回结果是true，那么执行{}中代码；
如果上面()中的表达式返回结果是false ，那么不执行{}中代码
PS:{}中的代码是否执行，取决于()中表达式的返回结果
}
（2）上面的代码中，我用四个单分支拼凑出四个选择，每个选择是独立的，依次判断执行的
（3）if后面的()中的条件，要按照自己需求尽量完善
（4）{}可以省略不写,但是一旦省略，这个if就只负责后面的一句话，所以我们不建议初学者省略
if-多分支
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部分。流程图如图所示：
练习：实现一个功能：给出三个数（1-6），对三个数求和计算，根据和的大小来分配不同的奖品
public class TestIf02{
public static void main(String[] args){
//1.给出三个数：
int num1 = 6;
int num2 = 4;
int num3 = 2;
//2.求和
int sum = 0;
sum += num1;
sum += num2;
sum += num3;
System.out.println("和为："+sum);
//3.根据和判断奖品：
if(sum>=14){
System.out.println("一等奖");
}else if(sum>=10){//隐藏了sum<14
System.out.println("二等奖");
}else if(sum>=6){//隐藏了sum<10
System.out.println("三等奖");
}else{//隐藏了sum<6
System.out.println("四等奖");
}
}
}
if-双分支
if(布尔表达式){
语句块1
}else{
语句块2
}
当布尔表达式为真时，执行语句块1，否则，执行语句块2。也就是else部分。
拓展：随机数
在java中依靠一个类：Math类帮助我们生成，这个类中有一个方法专门用来生成随机数：
Math.random() -------> [0.0,1.0)
Math.random()*6 ----->[0.0,6.0)
(int)(Math.random()*6) ----->[0,5]
(int)(Math.random()*6) +1 ----->[1,6]
上述使用过程中，需要注意初始为[左闭右开)区间分布原则
随机数练习：[32,98] - [0,66]+32 - (int)(Math.random()*67) + 32
public class TestIf07{
public static void main(String args[]){
/*
练习：[32,98] - [0,66]+32 - (int)(Math.random()*67) + 32
*/
int num1 = (int)(Math.random()*67)+32;//[0,66]+32=[32,98]
int num2 = (int)(Math.random()*67);
int num3 = (int)(Math.random()*67);
int sum = 0;
sum = num1-num2+32-num3+32;
System.out.println("结果为："+sum);//结果为[-36,162]区间内的数
}
}
分支结构练习
练习1：
不同积分享受的折扣不同，规则如下：
要求达到如下效果：
import java.util.Scanner;
public class TestIf08{
public static void main(String[] args){
//1.给出积分：
Scanner sc = new Scanner(System.in);
System.out.print("请输入会员积分：");
//先判断键盘录入的数据是不是int类型的
if(sc.hasNextInt()==true){//是int类型数据：
//将这个int类型的数据接收：
int score = sc.nextInt();
//判断这个积分是否是正数：
if(score>=0){
String discount = "";
//2.根据积分判断折扣：
if(score>=8000){
discount = "6";
}else if(score>=4000){
discount = "7";
}else if(score>=2000){
discount = "8";
}else{
discount = "9";
}
System.out.println("该会员享受的折扣为："+discount+"折");
}else{//score<0
System.out.println("对不起，您录入的积分是负数！不符合需求！");
}
}else{//不是int类型的数据
System.out.println("您录入的积分不是整数！");
}
}
}
练习2：
小朋友搬凳子：
年龄大于7岁，可以搬凳子；
如果年龄大于5岁，性别是男，可以搬凳子；
否则不可以搬动凳子，提示：你还太小了
import java.util.Scanner;
public class TestIf06{
public static void main(String[] args){
//输入年龄
System.out.println("小朋友，你几岁啦？");
Scanner sc = new Scanner(System.in);
//优化1：对非int类型数据的提示
if(sc.hasNextInt()==true){
int age = sc.nextInt();//接收该数值并进行判定折扣
if(age>7){
System.out.println("谢谢你的帮忙！");
}else if(age>5){
System.out.println("小朋友，你是男孩还是女孩？");
String str = sc.next();
char sex = str.charAt(0);
if(sex=='男'){
System.out.println("谢谢你的帮忙！");
}else if(sex=='女'){
System.out.println("女孩子搬不动哦！");
}else{
System.out.println("你只能是男孩或者女孩");
}
}else{
System.out.println("你太小啦！搬不动哦！");
}
}else{
System.out.println("不许调皮");
}
}
}
测试如下：
switch分支
语法结构：
switch (表达式) {
case 值1:
语句序列1;
[break];
case 值2:
语句序列2;
[break];
… … … … …
[default:默认语句;] } 流程图如图所示：
练习：实现一个功能：
根据给出的学生分数，判断学生的等级：
>=90 -----A
>=80 -----B
>=70 -----C
>=60 -----D
<60 -----E
public class TestSwitch{
public static void main(String[] args){
/*
实现一个功能：
根据给出的学生分数，判断学生的等级：
>=90 -----A
>=80 -----B
>=70 -----C
>=60 -----D
<60 -----E
用if分支：
if(score>=90){
}else if(score>=80){
}
*/
//1.给出学生的成绩：
int score = 97;
//2.根据成绩判断学生的等级：
switch(score/10){
case 10 :
case 9 : System.out.println("A级");break;
case 8 : System.out.println("B级");break;
case 7 : System.out.println("C级");break;
case 6 : System.out.println("D级");break;
default:System.out.println("成绩错误");break;
case 5 :
case 4 :
case 3 :
case 2 :
case 1 :
case 0 : System.out.println("E级");break;
}
}
}
**switch后面是一个()，()中表达式返回的结果是一个等值，这个等值的类型可以为：int,byte,short,char,String,枚举类型；
- switch分支()中的等值会依次跟case后面的值进行比较，如果匹配成功，就执行后面的代码；
- 为了防止代码的“穿透”效果：在每个分支后面加上一个关键词break，遇到break这个分支结束；
- 类似else的“兜底”“备胎”的分支：default分支。
- default分支可以写在任意的位置上，但是如果没有在最后一行，后面必须加上break关键字，如果在最后一行的话，break可以省略；
- 相邻分支逻辑是一样的，那么就可以只保留最后一个分支，上面的都可以省去不写了；
- switch应用场合：应用于多项等值判断，或者等值的情况比较少的情况下
if分支与switch分支的区别
switch分支和if分支区别：
表达式是等值判断的话——>if ，switch都可以
如果表达式是区间判断的情况——>if最好
循环结构
while循环
while (布尔表达式) {
循环体;
}
练习：
题1： 1+2+3+4+…+99+100
题2： 2+4+6+8+…+998+1000
题3： 5+10+15+20+…+100
题4： 99+97+95+93+…+3+1
题5： 13579*11
public class TestWhile01{
public static void main(String[] args){
//[1]
int num1 = 1;
int sum1 = 0;
while(num1<=100){
sum1 += num1;
num1++;
}
System.out.println("1+2+3+...+99+100的和为："+sum1);
//[2]
int num2 = 2;
int sum2 = 0;
while(num2<=1000){
sum2 += num2;
num2 = num2+2;
}
System.out.println("2+4+6+...+1000的和为："+sum2);
//[3]
int num3 = 5;
int sum3 = 0;
while(num3<=100){
sum3 += num3;
num3 = num3+5;
}
System.out.println("5+10+15+...+100的和为："+sum3);
//[4]
int num4 = 99;
int sum4 = 0;
while(num4>=1){
sum4 += num4;
num4 = num4-2;
}
System.out.println("99+97+...+3+1的和为："+sum4);
int num5 = 1;
int sum5 = 1;
while(num5<=11){
sum5 *= num5;
num5 = num5+2;
}
System.out.println("1*3*5*7*9*11的积为："+sum5);
}
}
总结：
- 循环作用：将部分代码重复执行。
循环只是提高了程序员编写代码的效率，但是底层执行的时候依然是重复执行。 - 循环四要素：
初始化谁，就判断谁，判断谁，就迭代谁;
执行过程：[1][2][3][4]——>[2][3][4]——>[2][3][4]。。。。 - 循环的执行过程：
【4】验证循环的执行过程：
do-while循环
do {
循环体;
} while(布尔表达式) ;do-while循环结构会先执行循环体，然后再判断布尔表达式的值，若条件为真，执行循环体，当条件为假时结束循环。do-while循环的循环体至少执行一次。do-while循环结构流程图如图所示：
练习：继续以1+2+3+…+99+100为例
public class TestDoWhile{
public static void main(String[] args){
//1+2+3+4+...100
//while方式:
/*
int i = 1;
int sum = 0;
while(i<=100){
sum += i;
i++;
}
System.out.println(i);
System.out.println(sum);
*/
//do-while方式：
int i = 1;
int sum = 0;
do{
sum += i;
i++;
}while(i<=100);
System.out.println(i);
System.out.println(sum);
}
}
while与do-while的区别与使用场景：
while和do-while的区别:
while:先判断，再执行；
do-while:先执行，再判断—》至少被执行一次，从第二次开始才进行判断
什么场合使用do-while:即事情一定会做，但结果暂未可知的情况下，例如：
while(考试是否通过){
考试；
}
—》while循环结构不合适
do{
考试；
}while(考试是否通过);
—》do-while循环结构合适
for循环
for (初始表达式; 布尔表达式; 迭代因子) {
循环体;
}
for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。for循环在第一次反复之前要进行初始化，即执行初始表达式；随后，对布尔表达式进行判定，若判定结果为true，则执行循环体，否则，终止循环；最后在每一次反复的时候，进行某种形式的“步进”，即执行迭代因子。
初始化部分设置循环变量的初值
条件判断部分为任意布尔表达式
迭代因子控制循环变量的增减
for循环在执行条件判定后，先执行的循环体部分，再执行步进。
for循环结构的流程图如图所示：
练习：
public class TestFor01{
public static void main(String[] args){
//1+2+3+..+100
//while:
/*int i = 1;
int sum = 0;
while(i<=100){
sum += i;
i++;
}
System.out.println(sum);
*/
//for:
int sum = 0;
int i;
for(i = 1;i<=100;i++){
sum += i;
}
System.out.println(sum);
System.out.println(i);
/*
【1】for的结构：
for(条件初始化;条件判断;迭代){
循环体；
}
【2】i的作用域：作用范围：离变量最近{} --->可以自己去控制
【3】for循环格式特别灵活：格式虽然很灵活，但是我们自己写代码的时候不建议灵活着写。
for(;;){} -->死循环
int i = 1;
for(;i<=100;){
sum += i;
i++;
}
【4】死循环：
for(;;){}
while(true){}
do{
}while(true);
【5】循环分为两大类：
第一类：当型 while(){} for(;;){}
第二类：直到型 do{}while();
【6】以后常用：for循环
【7】do-while,while,for循环谁的效率高？ 一样高
*/
}
}
循环关键字（break；continue；return）
- 在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句；
- continue 语句用在循环语句体中：用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定；
- return的作用：结束当前所在方法的执行。
练习1：输出1-100中可以被5整除的数字,每行输出6个
public class TestFor09{
public static void main(String[] args){
//引入一个计数器：
int count = 0;//初始值为0
for(int i=1;i<=100;i++){
if(i%5==0){//被5整除的数
System.out.print(i+"\t");
count++;//每在控制台输出一个数，count就加1操作
if(count%6==0){
System.out.println();//换行
}
}
}
}
}
练习2：实现一个功能：
【1】请录入10个整数，当输入的数是666的时候，直接退出程序。
【2】判断其中录入正数的个数并输出。
【3】判断系统的退出状态：是正常退出还是被迫退出。
import java.util.Scanner;
public class TestFor10{
public static void main(String[] args){
//引入一个计数器：
int count = 0;
//引入一个布尔类型的变量：用于判断异常退出用
boolean flag = true; //---》理解为一个“开关”，默认情况下开关是开着的
Scanner sc = new Scanner(System.in);
for(int i=1;i<=10;i++){//i:循环次数
System.out.println("请录入第"+i+"个数：");
int num = sc.nextInt();
if(num>0){//录入的正数
count++;
}
if(num==666){
flag = false;//当遇到666的时候，“开关”被关上了
//退出循环：
break;
}
}
System.out.println("你录入的正数的个数为："+count);
if(flag){//flag==true
System.out.println("正常退出！");
}else{//flag==false
System.out.println("被迫退出！");
}
}
}
循环的嵌套使用
双重循环
典型例题1：乘法口诀表
public class TestFor11{
public static void main(String[] args){
for(int j=1;j<=9;j++){
for(int i=1;i<=j;i++){
System.out.print(i+"*"+j+"="+i*j+"\t");
}
//换行
System.out.println();
}
}
}
例题2：使用“*”打印各种图形
- 长方形； 2. 前排空出一部分位置的长方形； 3. 平行四边形； 4. 三角形； 5. 菱形； 6. 空心菱形
public class TestFor11{
public static void main(String[] args){
System.out.println("----------1.长方形-----------");
for(int j=1;j<=4;j++){//j:控制行数
//*********
for(int i=1;i<=9;i++){//i:控制*的个数
System.out.print("*");
}
//换行：
System.out.println();
}
System.out.println("------2.前面有空隙的长方形--------");
for(int j=1;j<=4;j++){//j:控制行数
//加入空格：
for(int i=1;i<=5;i++){//i:控制空格的个数
System.out.print(" ");
}
//*********
for(int i=1;i<=9;i++){//i:控制*的个数
System.out.print("*");
}
//换行：
System.out.println();
}
System.out.println("-----------3.平行四边形------------");
for(int j=1;j<=4;j++){//j:控制行数
/*
平行四边形的空格有规律可循；
即行数与前面空格的数量之和不变
即（i空格数+j行数）=定值
*/
//加入空格：
for(int i=1;i<=(9-j);i++){//i:控制空格的个数
System.out.print(" ");
}
//*********
for(int i=1;i<=9;i++){//i:控制*的个数
System.out.print("*");
}
//换行：
System.out.println();
}
System.out.println("-----------4.三角形------------");
for(int j=1;j<=4;j++){//j:控制行数
//加入空格：
for(int i=1;i<=(9-j);i++){//i:控制空格的个数
System.out.print(" ");
}
//*********
for(int i=1;i<=(2*j-1);i++){//i:控制*的个数
System.out.print("*");
}
//换行：
System.out.println();
}
System.out.println("-----------5.菱形------------");
//上面三角形：
for(int j=1;j<=4;j++){//j:控制行数
//加入空格：
for(int i=1;i<=(9-j);i++){//i:控制空格的个数
System.out.print(" ");
}
//*********
for(int i=1;i<=(2*j-1);i++){//i:控制*的个数
System.out.print("*");
}
//换行：
System.out.println();
}
//下面三角形：
for(int j=1;j<=3;j++){//j:控制行数
//加入空格：
for(int i=1;i<=(j+5);i++){//i:控制空格的个数
System.out.print(" ");
}
//*********
for(int i=1;i<=(7-2*j);i++){//i:控制*的个数
System.out.print("*");
}
//换行：
System.out.println();
}
System.out.println("-----------6.空心菱形------------");
//上面三角形：
for(int j=1;j<=4;j++){//j:控制行数
//加入空格：
for(int i=1;i<=(9-j);i++){//i:控制空格的个数
System.out.print(" ");
}
//*********
for(int i=1;i<=(2*j-1);i++){//i:控制*的个数
if(i==1||i==(2*j-1)){
System.out.print("*");
}else{
System.out.print(" ");
}
}
//换行：
System.out.println();
}
//下面三角形：
for(int j=1;j<=3;j++){//j:控制行数
//加入空格：
for(int i=1;i<=(j+5);i++){//i:控制空格的个数
System.out.print(" ");
}
//*********
for(int i=1;i<=(7-2*j);i++){//i:控制*的个数
if(i==1||i==(7-2*j)){
System.out.print("*");
}else{
System.out.print(" ");
}
}
//换行：
System.out.println();
}
}
}
运行结果如图所示：
多重循环
经典例题：百钱买百鸡问题
描述：公鸡5文钱一只，母鸡3文钱一只，小鸡3只一文钱；用100文钱买一百只鸡,其中公鸡，母鸡，小鸡都必须要有，问公鸡，母鸡，小鸡要买多少只刚好凑足100文钱？
public class TestFor16{
public static void main(String[] args){
/*
百钱买百鸡：
公鸡5文钱一只，母鸡3文钱一只，小鸡3只一文钱，
用100文钱买一百只鸡,其中公鸡，母鸡，小鸡都必须要有，问公鸡，母鸡，小鸡要买多少只刚好凑足100文钱。
数学：
设未知数：
公鸡：x只
母鸡：y只
小鸡：z只
x+y+z=100只
5x+3y+z/3=100钱
麻烦方式：
for(int x=1;x<=100;x++){
for(int y=1;y<=100;y++){
for(int z=1;z<=100;z++){
if((x+y+z==100)&&(5*x+3*y+z/3==100)&&(z%3==0)){
System.out.println(x+"\t"+y+"\t"+z);
}
}
}
}
*/
//优化：
for(int x=1;x<=19;x++){
for(int y=1;y<=31;y++){
int z = 100-x-y;
if((5*x+3*y+z/3==100)&&(z%3==0)){
System.out.println(x+"\t"+y+"\t"+z);
}
}
}
}
}
846
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
