在所有的编程语言中遵循的最基础的代码结构是"顺序结构"
顺序结构:代码从上到下依次开始执行
在部分编程语言中,会在顺序结构中出现了特殊的流程控制
流程控制
流程控制语句(语句必须应用在代码块(方法)中)
分支结构
条件判断语句:if语句
条件选择语句:switch语句
循环结构
for语句
while语句
dowhile语句
流程控制代码块(暂不涉及,代码块必须应用在类文件中)
调用结构:
方法(在程序中执行特殊功能的代码块)
学习流程控制语句的小技巧:
1.记住流程控制语句的基本格式
2.记住流程控制语句的执行流程
3.理解并精通流程控制语句的实际应用
if语句的第一种格式:
if (条件判断语句) {
语句体
}
执行流程:
1.先确认条件判断语句的结果是true还是false
2.如果是true,执行语句体,if语句结束;
如果是false,if语句结束;
需求:
判断指定的整数是否为偶数,如果是进行打印
System.out.println("开始");
//声明并初始化一个整数
int num = 124;
//判断num是否为偶数
if (num % 2 == 0) {
System.out.println(num + "是偶数");
}
System.out.println("结束");
if语句的第二种格式
if (条件判断语句) {
语句体1
} else {
语句体2
}
执行流程:
1.先确认条件判断语句的结果是true还是false
2.如果是true,执行语句体1,if语句结束;
如果是false,执行语句体2,if语句结束;
需求:判断指定整数的奇偶性并进行打印
//声明并初始化一个整数
int num = 123;
//判断num是否为偶数
if (num % 2 == 0) {
System.out.println(num + "是偶数");
} else {
System.out.println(num + "是奇数");
}
三元运算符和if语句第二种格式的注意事项:
在实际开发中更推荐使用if语句第二种格式,因为三元运算符具有一定的局限性,最终执行的代码只能是结果值,只有在非常简单且 *** 作值的if语句可以用三元运算符进行改写
//声明并初始化一个整数
int num = 124;
//判断num是否为偶数
if (num % 2 == 0) {
System.out.println(num + "是偶数");
} else {
System.out.println(num + "是奇数");
}
System.out.println("====================");
String result = num % 2 == 0 ? (num + "是偶数") : (num + "是奇数");
System.out.println(result);
if语句的第三种格式:
if (条件判断语句1) {
语句体1
} else if (条件判断语句2) {
语句体2
}
......
else if (条件判断语句n) {
语句体n
} else {
语句体n+1
}
执行流程:
1.先确认条件判断语句1的结果是true还是false;
2.如果是true,执行语句体1,if语句结束;
如果是false,再确认条件判断语句2的结果是true还是false;
......
3.当所有的条件判断语句的结构都是false时,执行else中的语句体n+1
注意事项:
if语句的第三种格式可以将else语句省略不写,但可能存在安全隐患,推荐写上
需求:判断两个执行整数之间的关系(<,>,=)
//声明并初始化两个整数
int a = 4;
int b = 4;
//进行关系判断
if (a > b) {
System.out.println("a > b");
} else if (a < b) {
System.out.println("a < b");
} else {
System.out.println("a == b");
}
exer1 :
x和y的关系满足如下：
x>=3 y = 2x + 1;
-1 //声明并初始化x变量
int x = 5;
//声明变量y
int y;
//考虑到有3种选择情况,选择if语句第3种格式
if (x >= 3) {
y = 2 * x + 1;
} else if (x > -1 && x < 3) {
y = 2 * x;
} else {
y = 2 * x - 1;
}
System.out.println("y = " + y);
exer2：通过指定考试成绩，判断学生等级
90-100 优秀
80-89 好
70-79 良
60-69 及格
60以下 不及格
//声明并初始化学生的考试成绩
int score = 100;
//判断学生考试成绩的有效性
if (score >= 0 && score <= 100) {
if (score >= 90 && score <= 100) {
System.out.println("优秀");
} else if (score >= 80 && score <= 89) {
System.out.println("好");
} else if (score >= 70 && score <= 79) {
System.out.println("良");
} else if (score >= 60 && score <= 69) {
System.out.println("及格");
} else {
System.out.println("不及格");
}
} else {
System.out.println("成绩有误");
}
switch语句的格式:
switch (数据值) {
case 数据值1:
语句体1
break;
case 数据值2:
语句体2
break;
......
case 数据值n:
语句体n
break;
default:
语句体n+1
break;
}
执行流程:
1.先确认switch()中的数据值是多少;
2.选择数据值1和switch()中的数据值进行匹配,看是否匹配成功;
3.如果匹配成功,执行语句体1,执行break,switch语句结束;
如果匹配失败,选择数据值2和switch()中的数据值进行匹配,看是否匹配成功;
......
4.当所有选择的数据值都和switch()中的数据值匹配失败,执行default中的语句体n+1,执行break,
需求: 通过数字匹配星期
//声明并初始化指定数字
int weekday = 5;
//进行选择
switch (weekday) {
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;
}
switch语句的注意事项:
1.switch语句()中数据值的数据值:
基本类型:
原则上基本类型只支持int类型数据,考虑到自动提升,基本类型也支持byte,short,char即使是这三种数据类型,进行到switch语句中也会自动提升成int型
引用类型:
在JDK5.0(包含)以后,支持枚举类型Enum
在JDK7.0(包含)以后,支持字符串类型String
2.switch语句中default语句的作用和if语句第三种格式中else作用类似,都可以省略不写,推荐default写上
3.switch语句中case和default的位置可以互换,但不影响编译,推荐将default写在case下面
4.switch语句中break可以省略不写,但是会出现case穿透效果
int num = 5;
switch (num) {
case 1:
System.out.println("你好");
//break;
case 2:
System.out.println("我好");
//break;
case 3:
System.out.println("大家好");
//break;
default:
System.out.println("他好我也好");
//break;
}
需求：定义一个月份，输出该月份对应的季节。
一年有四季
3,4,5 春季
6,7,8 夏季
9,10,11 秋季
12,1,2 冬季
分析：
A:指定一个月份
B:判断该月份是几月,根据月份输出对应的季节
if
switch
if语句和switch语句在实际开发中更推荐使用if语句,if语句的判断条件可以表示范围,
而switch语句只能表示数据值,从内存角度分析,switch语句执行过程中更节约内存,
但是节约的内存在硬件过剩的今天可以忽略不计
switch (month) {
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;
case 1:
case 2:
case 12:
System.out.println("冬季");
break;
default:
System.out.println("月份有误");
break;
}
for语句的格式:
for (初始化语句;循环条件语句;迭代语句) {
循环体语句
}
名词解释:
初始化语句:声明并初始化的循环变量
循环条件语句:判断循环变量是否满足循环的条件
迭代语句:循环的后续 *** 作
循环体语句:重复执行多次的代码片段
执行流程:
1.先执行初始化语句;
2.再确认循环条件语句的结果是true还是false;
3.如果是true,执行循环体语句;
如果是false,for语句结束;
4.执行迭代语句
5.跳回第2步,继续执行
需求:打印10遍HelloWorld
for (int i = 1; i <= 10 ; i++) {
System.out.println("HelloWorld");
}
通过循环语句打印1-5和5-1
注意事项:
for语句中的初始化语句声明的变量只在for的()中和{}中有效
for (int i = 1; i <= 5 ; i++ ) {
System.out.println(i);
}
System.out.println("========================");
for (int i = 5; i >= 1; i-- ) {
System.out.println(i);
}
使用循环求出1-5之间数据之和
//声明并初始化求和变量
int sum = 0;
for (int i = 1; i <= 5 ; i++ ) {
sum += i;//sum = sum + i;
}
System.out.println("sum = " + sum);
练习：求出1-100之间偶数和
//声明初始化求和变量
int sum = 0;
//遍历1-100之间所有的整数
for (int i = 1; i <= 100 ; i++ ) {
//进行数据的筛选
if (i % 2 == 0) {
sum += i;
}
}
//打印求和变量
System.out.println("sum = " + sum);
练习：打印所有的水仙花数
分析：
什么是水仙花数呢?
所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。
举例：153就是一个水仙花数。
153 = 1*1*1 + 5*5*5 + 3*3*3
1.三位数其实就告诉了我们水仙花数的范围
100-999
2.如何获取一个数据的每一个位上的数呢?
举例：我有一个数据153，请问如何获取到个位，十位，百位
个位：153%10 = 3;
十位：153/10%10 = 5;
百位：153/10/10%10 = 1;
千位：...
万位：...
3.让每个位上的立方和相加，并和该数据进行比较，如果相等，就说明该数据是水仙花数，在控制台输出
//遍历所有的三位数
for (int i = 100; i < 1000 ; i++ ) {
//获取每个三位数的个位,十位,百位
int ge = i % 10;
int shi = i / 10 % 10;
int bai = i / 100 % 10;
//数据的筛选
if (i == bai*bai*bai + shi*shi*shi + ge*ge*ge) {
System.out.println(i);
}
}
练习：打印所有的水仙花数共***有多少个***
//声明并初始化水仙花数的计数器变量
int count = 0;
//遍历所有的三位数
for (int i = 100 ; i < 1000 ; i++) {
//获取每个三位数上的个位,十位,百位
int ge = i % 10;
int shi = i / 10 % 10;
int bai = i / 100 % 10;
//进行数据的筛选
if (i == bai*bai*bai + shi*shi*shi + ge*ge*ge) {
//计数器变量累加
count++;
}
}
//打印计数器变量
System.out.println("水仙花数共有" + count + "个");
分析以下需求，并用代码实现：
(1)打印出四位数字中个位+百位=十位+千位并且个位数为偶数，千位数为奇数的数字,并打印符合条件的数字的个数
(2)符合条件的数字,每行显示5个,用空格隔开,打印格式如下:
1012 1034 1056 1078 1100
1122 1144 1166 1188 1210
//......
符合条件的数字总共有: 165个
//声明并初始化计数器变量
int count = 0;
//遍历所有四位数
for (int i = 1000; i < 10000 ; i++) {
int ge = i % 10;
int shi = i / 10 % 10;
int bai = i / 100 % 10;
int qian = i / 1000 % 10;
//进行条件的筛选
if ((ge + bai == shi + qian) && (ge % 2 == 0) && (qian % 2 == 1)) {
//计数器累加
count++;
//打印符合要求的数字
if (count % 5 == 0) {
System.out.println(i);
} else {
System.out.print(i + " ");
}
}
}
System.out.println("符合条件的数字总共有: " + count + "个");
while语句的格式:
while (循环条件语句) {
循环体语句
}
执行流程:
1.确认循环条件语句的结果是true还是false;
2.如果是true,执行循环体语句;
如果是false,while语句结束;
3.跳回第1步,继续执行
为了和for语句进行互换,衍生出while的扩展格式
初始化语句
while (循环条件语句) {
循环体语句
迭代语句
}
for (int i = 1 ; i <= 10 ; i++) {
System.out.println("HelloWorld");
}
System.out.println("=========================");
int i = 1;
while (i <= 10) {
System.out.println("HelloWorld");
i++;
}
趣味折纸:
题目：
世界最高山峰是珠穆朗玛峰，它的高度是8848.86米，假如我有一张足够大的纸，它的厚度是0.1毫米。
请问，折叠多少次，不低于珠穆朗玛峰的高度?
//声明初始化珠峰高度变量
int zf = 88488600;
//声明初始化纸的厚度变量
int zhi = 1;
int count = 0;
//考虑到不清楚循环次数或循环范围,使用while语句
while (zhi < zf) {
count++;
//进行折叠
zhi *= 2;
}
System.out.println("count = " + count);
dowhile语句的格式:
do {
循环体语句
} while (循环条件语句);
执行流程:
1.执行循环体语句
2.再确认循环条件语句的结果是true还是false
3.如果是true,跳回第1步继续执行;
如果是false,dowhile语句结束;
为了和for循环语句进行转换,衍生出dowhile循环扩展格式
初始化语句
do {
循环体语句
迭代语句
} while(循环条件语句);
for (int i = 1; i <= 10 ; i++ ) {
System.out.println("HelloWorld");
}
System.out.println("======================");
int i = 1;
do {
System.out.println("HelloWorld");
i++;
} while (i <= 10);
三种循环的区别:
从代码格式角度分析:
1.循环变量的作用域不同:
for语句的循环变量在循环结束后自动消失达到节约内存目的,while和dowhile扩展格式语句循环变量需要等到所在方法结束后才进行消失,浪费内存资源
2.执行相同需求,循环条件语句判断次数不同
dowhile语句的循环条件语句判断次数比for语句和while语句少一次
3.循环体语句最少执行次数
for语句和while语句循环体语句最少执行0次
dowhile语句循环体语句最少执行1次
从实际开发角度分析:
1.有明显的循环范围或次数选择for语句进行遍历
2.没有明显循环范围或次数选择while语句进行遍历
3.在实际开发中不会选择dowhile
(1)当别人的代码出现了dowhile语句,我们可以看懂格式和分析执行流程
(2)部分源码中会遇到dowhile语句
for (int i = 1; i <= 10 ; i++ ) {
System.out.println("HelloWorld");
}
System.out.println("=========================");
int i = 1;
while (i <= 10) {
System.out.println("HelloWorld");
i++;
}
System.out.println("======================");
int j = 1;
do {
System.out.println("HelloWorld");
j++;
} while (j <= 10);
流程控制语句的注意事项(针对if语句第一种格式,for语句,while语句):
当流程控制语句(dowhile除外)里面的语句体有且仅有一句的时候,流程控制语句的{}可以省略不写,如果不写代码阅读性较低,所以推荐写上
System.out.println("开始");
if (false)
System.out.println("Hello");
System.out.println("World");
System.out.println("结束");
System.out.println("============================");
for (int i = 1; i <= 10 ;i++ )
System.out.println("Hello");
System.out.println("World");
控制语句:
break
continue
return(暂不涉及)
break关键字:
场景:
1.switch语句中
2.循环语句中
作用:
1.结束switch语句
2.结束循环语句
continue关键字:
场景:
循环语句中
作用:
结束当次循环,继承下一次循环
控制语句的注意事项:
在控制语句同一作用域内,控制语句后面不写编写任何代码,否则编译报错,因为永远执行不到
for (int i = 1; i <= 10 ; i++ ) {
if (i == 3) {
break;
System.out.println("HelloWorld");
}
System.out.println(i);
}
死循环语句:
含义:循环条件语句永远判断为true的循环
分类:
for死循环语句
while死循环语句
格式:
for的死循环格式:
for (;;) {
循环体语句
}
while的死循环格式:
while (true) {
循环体语句
}
区别:
在实际开发中更推荐选择while的死循环格式,格式上更简洁明了;在编写框架源码,算法,设计模式等,更推荐使用for的死循环格式,for的死循环格式效率更高
for (; ;) {
System.out.println("HelloWorld");
}
while (true) {
System.out.println("HelloWorld");
}
循环嵌套:
在一个循环语句中存在另外一个循环语句(循环嵌套往往指代的是for语句嵌套)
内层循环:在循环嵌套中存在内部的循环语句
外层循环:在循环嵌套中存在外部的循环语句
内层循环和外层循环是一对相对的概念
循环嵌套语句的格式:
for (外层循环的初始化语句;外层循环的循环条件语句;外层循环的迭代语句) {
for (内层循环的初始化语句;内层循环的循环条件语句;内层循环的迭代语句) {
内层循环的循环体语句
}
}
执行流程:
1.执行外层循环的初始化语句;
2.确认外层循环的循环条件语句的结果是true还是false;
3.如果是false,for语句嵌套语句结束;
如果是true,执行外层循环的循环体语句,开始执行第a步;
a.执行内层循环的初始化
b.确认内层循环的循环条件语句的结果是true还是false;
c.如果是false,内层循环语句结束,开始执行第4步;
如果是true,执行内层循环的循环体语句;
d.执行内层循环的迭代语句;
e.跳回第b步,继续执行;
4.执行外层循环的迭代语句;
5.跳回第2步,继续执行
需求:按照固定的格式打印一天中的时间
固定格式: X时X分
for (int h = 0; h < 24 ; h++) {
for (int m = 0; m < 60 ; m++) {
System.out.println(h + "时" + m + "分");
}
}
循环嵌套语句的注意事项:
外层循环的初始化语句执行了1次
内层循环的初始化语句执行了(外层循环的循环次数)次
内层循环的循环体语句执行了(外层循环的循环次数*内层循环的循环次数)次
花100文钱买100只鸡
公鸡5文1只
母鸡3文1只
小鸡1文3只
花100文钱正好买100只鸡
分析:
一种一种的可能性进行尝试
//gong代表公鸡只数
for (int gong = 0; gong <= 100 ; gong++ ) {
//mu代表母鸡只数
for (int mu = 0; mu <= 100 ; mu++ ) {
//xiao代表小鸡只数
for (int xiao = 0; xiao <= 100 ; xiao++) {
//进行数据的筛选
if ((xiao % 3 == 0) && (gong + mu + xiao == 100) && (5*gong + 3*mu + xiao/3 == 100)) {
System.out.println("公鸡" + gong + "只,母鸡" + mu + "只,小鸡" + xiao + "只");
}
}
}
}
百钱买百鸡的优化
//循环次数:1030301
//gong代表公鸡只数
for (int gong = 0; gong <= 100 ; gong++ ) {
//mu代表母鸡只数
for (int mu = 0; mu <= 100 ; mu++ ) {
//xiao代表小鸡只数
for (int xiao = 0; xiao <= 100 ; xiao++) {
//进行数据的筛选
if ((xiao % 3 == 0) && (gong + mu + xiao == 100) && (5*gong + 3*mu + xiao/3 == 100)) {
System.out.println("公鸡" + gong + "只,母鸡" + mu + "只,小鸡" + xiao + "只");
}
}
}
}
System.out.println("======================================");
//循环次数:72114
for (int gong = 0; gong <= 20 ; gong++ ) {
for (int mu = 0; mu <= 33 ; mu++ ) {
for (int xiao = 0; xiao <= 100 ; xiao++) {
if ((xiao % 3 == 0) && (gong + mu + xiao == 100) && (5*gong + 3*mu + xiao/3 == 100)) {
System.out.println("公鸡" + gong + "只,母鸡" + mu + "只,小鸡" + xiao + "只");
}
}
}
}
System.out.println("======================================");
//循环次数:714
for (int gong = 0; gong <= 20 ; gong++ ) {
for (int mu = 0; mu <= 33 ; mu++ ) {
int xiao = 100 - gong - mu;
if ((xiao >= 0) && (xiao % 3 == 0) && (5*gong + 3*mu + xiao/3 == 100)) {
System.out.println("公鸡" + gong + "只,母鸡" + mu + "只,小鸡" + xiao + "只");
}
}
}
System.out.println("======================================");
//循环次数:714
for (int gong = 0; gong <= 20 ; gong++ ) {
for (int xiao = 0; xiao <= 100 ; xiao += 3 ) {
int mu = 100 - gong - xiao;
if ((mu >= 0) && (5*gong + 3*mu + xiao/3 == 100)) {
System.out.println("公鸡" + gong + "只,母鸡" + mu + "只,小鸡" + xiao + "只");
}
}
}
打印1-100之间所有的质数
质数的特点:
1.只能被1或本身进行整除
2.1不是质数
分析:
通过分析发现质数的因数只有2个,除了这2次外再可以进行整除的数都不会是质数
//外层循环:控制被除数 循环次数:1133
for (int i = 2; i <= 100 ; i++) {
//声明并初始化被除数质数标记变量(true为质数,false不是质数)
boolean flag = true;
//内层循环:控制除数
for (int j = 2; j < i ; j++) {
//进行整除判断
if (i % j == 0) {
//判定该被除数肯定不是质数,修改标记变量
flag = false;
break;
}
}
//判断被除数因数的个数
if (flag) {
System.out.println(i);
}
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）