1.流程控制
1.1 概述
在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。所以，我们必须清楚每条语句的执行流程。而且，很多时候要通过控制语句的执行顺序来实现我们想要的功能。
例如: 某些代码是满足特定条件的情况下, 才会被执行. 而有些代码, 在满足某些条件的情况下, 需要重复执行, 这些, 都需要用到流程控制语句.
1.2 分类
顺序结构
选择结构(if语句, switch.case语句)
循环结构(for循环, while循环, do.while循环)
1.3 顺序结构
1.3.1 概念
顺序结构指的是代码是按照从上往下, 从左往右的顺序, 依次逐行执行的, 且顺序结构也是Java程序的默认结构
1.3.2 图解
1.3.3 例子
需求：定义一个类，在类中定义main方法, 打印如下数据:
//start
//HelloWorld1
//HelloWorld2
//HelloWorld3
//end
参考代码
public class Demo01 {
public static void main(String[] args) {
//打印指定的数据
System.out.println("start");
System.out.println("HelloWorld1");
System.out.println("HelloWorld2");
System.out.println("HelloWorld13");
System.out.println("end");
}
}
1.4 选择结构
1.4.1 概述
如果我们想某些代码是在满足条件的情况下, 才能被执行, 此时就需要用到选择结构了, 选择结构也叫分支结构, 主要分为以下两种:
if语句
switch.case语句
1.4.2 分类
if语句一般用于范围的判断, 例如: 如果当前时间是0~8点, 小黑就和你说: 早上好, 如果当前时间是9 ~12点, 小黑就和你说: 中午好. 根据应用场景的不同(即: 分支个数不同), if语句的格式主要分为以下三种:
if语句(也叫: 单分支)
if.else语句(也叫: 双分支)
if.else if语句(也叫: 多分支)
1.4.3 单分支
单分支结构一般用来判断一种情况, 格式如下:
if(关系表达式) {
语句体;
}
执行流程
1.先执行关系表达式, 看其结果是true还是false
2.如果是true, 则执行大括号中的语句体
3.如果是false, 则大括号中的语句体不执行
图解
例子
需求
定义变量time表示时间, 如果它的范围是在[0,8]之间, 就打印早上好, 否则不操作
解释: [0, 8], 意思是说 0~8之间, 包含0, 也包含8, 这种写法属于"前闭后闭"
[0, 8), 意思是: 0~8之间, 包含0, 不包含8, 这种写法属于"前闭后开", 也叫: 包左不包右
参考代码
public class Demo02 {
public static void main(String[] args) {
int time = 5;
if(time >= 0 && time <= 8) {
System.out.println("早上好");
}
}
}
1.4.4 双分支
双分支结构指的是if. else语句, 一般用来判断两种情况, 格式如下:
if(关系表达式) { //if的意思: 如果
//语句体1;
} else { //否则...
//语句体2;
}
执行流程
1.先执行关系表达式, 看其结果是true还是false
2.如果是true, 则执行语句体1
3.如果是false, 则执行语句体2
图解
案例一
需求
定义变量time表示时间, 如果它的范围是在0~8之间, 就打印早上好, 否则就打印中午好
参考代码
public class Demo03 {
public static void main(String[] args) {
int time = 5;
if(time >= 0 && time <= 8) {
System.out.println("早上好");
} else {
System.out.println("中午好");
}
案例二: 判断奇偶数
需求
提示用户键盘录入一个数据并接收
判断该数据是奇数还是偶数, 并将结果打印到控制台上
参考代码
public class Demo04 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请录入一个整数: ");
int num = sc.nextInt();
if (num % 2 == 0) {
System.out.println(num + "是偶数");
} else {
System.out.println(num + "是奇数");
}
}
}
注
1.if语句控制的语句体如果只有一行代码, 则该大括号可以省略不写
例如:
if(5 > 3){
System.out.println("马上开学啦!");
}
2.if语句控制的语句体如果只有一行代码, 则该大括号可以省略不写, 定义变量的语法除外
例如:
if(5 > 3){
int a = 10; //这样写会报错, jvm会识别这样代码为两行: int a; a = 10;
}
上述的代码就相当于:
if(5 > 3) {
int a;
a = 10; //这样写肯定会报错
}
3.你省略if后边的大括号时, 有个问题一定要注意, 不要乱写分号
例如:
if(5 > 3) ; //这里如果写分号了, 就意味着if语句结束了.
System.out.println("本意: 这行代码只有条件成立才会被执行");
1.4.5 多分支
多分支结构指的是if. else if语句, 一般用来判断多种情况, 格式如下:
if(关系表达式1) {
//语句体1;
} else if(关系表达式2){
//语句体2;
} else if(关系表达式3){ //这里可以根据需求, 有多个else if语句
//语句体3;
} else {
//语句体n;
}
执行流程
1.先执行关系表达式1, 看其结果是true还是false
2.如果是true, 则执行语句体1, 整个if语句结束
3.如果是false, 则判断关系表达式2, 看其结果是true还是false
4.如果是true, 则执行语句体2, 整个if语句结束
5.如果是false, 则判断关系表达式3, ...以此类推
6.如果所有的关系表达式都不成立, 则执行else语句的语句体n, 整个if语句结束
图解
案例一: 打印星期
需求
提示用户录入[1, 7]之间的数字, 并接收.
根据用户录入的数字, 打印对应的星期, 格式如下:
用户录入1, 打印"星期一"
用户录入2, 打印"星期二"
...以此类推
用户录入非法数字, 打印"没有这样的日期
参考代码
package com.company;
import java.util.Scanner;
public class Test10 {
public static void main(String[] args) {
// 提示用户录入[1, 7]之间的数字, 并接收.
System.out.println("请输入一个整数数字：");
Scanner sc = new Scanner(System.in);
int data = sc.nextInt();
System.out.println("您输入的整数数字为：" +data);
// 根据用户录入的数字, 打印对应的星期, 格式如下:
// 用户录入1, 打印"星期一"
// 用户录入2, 打印"星期二"
//...以此类推
if(data == 1){
System.out.println("今天是星期一");
}
else if(data == 2){
System.out.println("今天是星期二");
}
else if(data == 3){
System.out.println("今天是星期三");
}
else if(data == 4){
System.out.println("今天是星期四");
}
else if(data == 5){
System.out.println("今天是星期五");
}
else if(data == 6){
System.out.println("今天是星期六");
}
else if(data == 7){
System.out.println("今天是星期天");
}
// 用户录入非法数字, 打印"没有这样的日期"
else{
System.out.println("没有这样的日期");
}
}
}
案例二: 发放奖励
需求
小明快要期末考试了，小明爸爸对他说，会根据他的考试成绩，送他不同的礼物.
假如你可以控制小明的得分，请用程序实现小明到底该获得什么样的礼物，并在控制台输出。
礼物标准如下:
95~100 山地自行车一辆
90~94 游乐场玩一次
80~89 变形金刚玩具一个
80以下 胖揍一顿
参考代码
package com.company;
import java.util.Scanner;
public class Test11 {
public static void main(String[] args) {
System.out.println("请输入小明的考试成绩：");
Scanner sc = new Scanner(System.in);
int score = sc.nextInt();
if(score > 100 || score < 0){
System.out.println("请输入合法成绩");
}
else if(score <=100 && score >= 95){
System.out.println("老爸奖励小明山地自行车一辆");
}
else if(score <=94 && score >= 90){
System.out.println("老爸领小明去游乐场玩一次");
}
else if(score <=89 && score >= 80){
System.out.println("老爸奖励小明变形金刚玩具一个");
}
else{
System.out.println("恭喜小明，成功引起老爸注意，被胖揍一顿");
}
}
}
案例三: 获取最大值
需求
提示用户录入3个整数, 并接收
通过if语句获取这三个整数的最大值
将结果打印到控制台上
参考代码
import java.util.Scanner;
public class Demo06 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请录入第一个整数: ");
int a = sc.nextInt();
System.out.println("请录入第二个整数: ");
int b = sc.nextInt();
System.out.println("请录入第三个整数: ");
int c = sc.nextInt();
//方式一: if嵌套实现.
int max = a;
int max2 = a;
if (a > b) {
if (a > c) {
max = a;
} else {
max = c;
}
} else {
if(b > c) {
max = b;
} else {
max = c;
}
}
System.out.println("最大值: " + max);
//方式二: if. else.if语句实现
if (a > b && a > c) {
max2 = a;
} else if(b > a && b > c) {
max2 = b;
} else {
max2 = c;
}
System.out.println("最大值: " + max2);
}
}
1.4.6 switch语句
概述
switch语句, 一般是用于做固定值判断的, 在实际开发中, 用到的频率也非常高
格式
switch(表达式) {
case 值1:
语句体1;
break;
case 值2:
语句体2;
break;
case 值3:
语句体3;
break;
... //根据需求, 可以写多组case.
default:
语句体n;
break;
}
格式详解
执行流程
1.先计算表达式的值, 然后按照从上往下的顺序依次和每一个case对应的值相匹配
2.如果能匹配成功, 则执行该case对应的语句体, 然后执行break, 至此, 整个switch语句结束
3.如果和所有的case值都不匹配, 则执行default对应的语句体, 然后执行break, 至此, 整个switch语句结束
解释: default语句就类似于if. else语句中的else, 当所有条件都不满足时才会执行
执行流程图解
示例一: 春夏秋冬
需求
一年有12个月, 分属于春夏秋冬4个季节, 键盘录入一个月份, 请用程序实现判断该月份属于哪个季节, 并输出。
具体标准如下:
输入： 1、2、12 输出：冬季
输入： 3、4、5 输出：春季
输入： 6、7、8 输出：夏季
输入： 9、10、11 输出：秋季
输入：其它数字 输出：数字有误
参考代码
import java.util.Scanner;
public class Demo07 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请录入一个月份: ");
int month = sc.nextInt();
switch (month) {
case 12:
System.out.println("冬季");
break;
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;
case 8:
System.out.println("夏季");
break;
case 9:
System.out.println("秋季");
break;
case 10:
System.out.println("秋季");
break;
case 11:
System.out.println("秋季");
break;
default:
System.out.println("没有这样的日期");
break;
}
}
}
1.4.7 case穿透
概述
在switch语句中，如果case的后面不写break，将出现case穿透现象，也就是不会在判断下一个case的值，直接向后运行，直到遇到break，或者整体switch结束
格式
switch(表达式) {
case 值1:
语句体1; //假设表达式的值 = 值1, 则执行完语句体1后, 不会判断第二个case, 直接执行语句体2;
break;
case 值2:
语句体2;
break;
case 值3:
语句体3;
break;
... //根据需求, 可以写多组case.
default:
语句体n;
break;
}
案例：简化春夏秋冬
需求
通过case穿透, 优化刚才的春夏秋冬案例
参考代码
import java.util.Scanner;
public class Demo08 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请录入一个月份: ");
int month = sc.nextInt();
switch (month) {
case 12:
case 1:
case 2:
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("没有这样的日期");
break;
}
}
}
思考题
1.switch语句的小括号中, 可以放什么?
switch()，这个括号里面一般表示的是整数，包括，short,byte和int类型，char和String类型也可以，但是long类型和浮点型的小数就不能往这里放了
2.default语句必须放到switch语句的最后吗?
default语句不是必须放在case语句的结尾处出现 switch的执行是按照从小到大的顺序执行的，最后执行default语句， 如果default后面带有break，那么程序就会正常跳出switch，否则， 程序会继续向后执行switch语句！也就是说，不管default放在什么 位置，它总是在最后一个处理，然后继续向下处理！ 所以，最后的处理办法，避免出现以外结果的最好办法就是每一个case 以及default语句都要加一个break!
3.break关键字可以省略吗? 对执行结果是否有影响?
可以
在switch语句中，如果case的后面不写break，将出现case穿透现象，也就是不会在判断下一个case的值，直接向后运行，直到遇到break，或者整体switch结束
案例：发放奖励
需求
1.小明快要期末考试了，小明爸爸对他说，会根据他的考试成绩，送他不同的礼物.
2.假如你可以控制小明的得分，请用程序实现小明到底该获得什么样的礼物，并在控制台输出。
3.礼物标准如下:
90~100 山地自行车一辆
80~89 游乐场玩一次
70~79 变形金刚玩具一个
70以下 胖揍一顿
参考代码
package com.company;
import java.util.Scanner;
public class Test14 {
public static void main(String[] args) {
System.out.println("请输入小明的考试成绩：");
Scanner sc = new Scanner(System.in);
int score = sc.nextInt();
if (score >= 0 && score <= 100) {
switch (score / 10) {
case 10:
case 9:
System.out.println("老爸奖励小明山地自行车一辆");
break;
case 8:
System.out.println("老爸领小明去游乐场玩一次");
break;
case 7:
System.out.println("老爸奖励小明变形金刚玩具一个");
break;
default:
System.out.println("恭喜小明，成功引起老爸注意，被胖揍一顿");
break;
}
}
else{
System.out.println("请输入合法成绩");
}
}
}
1.4.8 练习题
案例一: 涨工资
需求
根据工龄(整数)给员工涨工资(整数), 工龄和基本工资通过键盘录入
涨工资的条件如下：
[10-15) +5000
[5-10) +2500
[3~5) +1000
[1~3) +500
[0~1) +200
打印格式
您目前工作了10年，基本工资为 3000元, 应涨工资 5000元,涨后工资 8000元
参考代码
package com.company;
import java.util.Scanner;
public class Test15 {
public static void main(String[] args) {
System.out.println("请输入工龄：");
Scanner sc = new Scanner(System.in);
int age = sc.nextInt();
System.out.println("请输入基本工资：");
Scanner scc = new Scanner(System.in);
int money = scc.nextInt();
int add_money;
int money_money;
if(age >= 0 && age < 15){
switch(age){
case 14:
case 13:
case 12:
case 11:
case 10:
add_money = 5000;
money_money = money + add_money;
System.out.println("您目前工作了"+age+"年，基本工资为"+money+"元，应涨工资"+add_money+"元，" +
"涨后工资"+money_money+"元");
break;
case 9:
case 8:
case 7:
case 6:
case 5:
add_money = 2500;
money_money = money + add_money;
System.out.println("您目前工作了"+age+"年，基本工资为"+money+"元，应涨工资"+add_money+"元，" +
"涨后工资"+money_money+"元");
break;
case 4:
case 3:
add_money = 1000;
money_money = money + add_money;
System.out.println("您目前工作了"+age+"年，基本工资为"+money+"元，应涨工资"+add_money+"元，" +
"涨后工资"+money_money+"元");
break;
case 2:
case 1:
add_money = 500;
money_money = money + add_money;
System.out.println("您目前工作了"+age+"年，基本工资为"+money+"元，应涨工资"+add_money+"元，" +
"涨后工资"+money_money+"元");
break;
default:
add_money = 200;
money_money = money + add_money;
System.out.println("您目前工作了"+age+"年，基本工资为"+money+"元，应涨工资"+add_money+"元，" +
"涨后工资"+money_money+"元");
break;
}
}
else{
System.out.println("请输入合法工龄");
}
}
}
案例二: 定义计算器
需求
1.功能描述：模拟计算器功能，对键盘录入的两个int类型的数据进行加、减、乘、除的运算，并打印运算结果
2.要求：
(1)键盘录入三个整数,其中前两个整数代表参加运算的数据，
第三个整数为要进行的运算(0:表示加法运算,1:表示减法运算,2:表示乘法运算,3:表示除法运算)
(2)使用今天所学知识完成功能
(3)演示格式如下:
请输入第一个整数:30
请输入第二个整数:40
请输入您要进行的运算(0:表示加法运算,1:表示减法运算,2:表示乘法运算,3:表示除法运算):0
控制台输出:30+40=70
参考代码
package com.company;
import java.util.Scanner;
/**
* @author Liu
* @date 2020/4/12 15:17
*/
public class Test16 {
public static void main(String[] args) {
System.out.println("请输入第一个整数：");
Scanner sc = new Scanner(System.in);
int a=sc.nextInt();
System.out.println("请输入第二个整数：");
Scanner scc = new Scanner(System.in);
int b=scc.nextInt();
System.out.println("请输入您要进行的计算(0：表示加法运算，1:表示减法运算，2：表示乘法运算，3：表示除法运算)");
Scanner sccc = new Scanner(System.in);
int c=sccc.nextInt();
if (c == 0){
System.out.println("a + b ="+(a+b));
}else if(c == 1){
System.out.println("a - b ="+(a-b));
}else if(c == 2){
System.out.println("a * b ="+(a*b));
}else if(c == 3){
System.out.println("a / b ="+(a/b));
}else{
System.out.println("请输入正确的值");
}
}
}
案例三: 水仙花数
需求
键盘录入一个三位数字,输出该三位数字是否是水仙花数字?
水仙花数字要求: 指的是一个三位数，个位、十位、百位的数字立方和等于原数
例如 153 333 + 555 + 111 = 27 + 125 + 1 = 153
实现步骤
1.创建键盘录入对象
2.获取一个int数字
3.获取个位,十位,百位
4.求个位,十位,百位的立方和
5.利用if语句判断立方和是否等于该数字本身,并输出结果
参考代码
package com.company;
import java.util.Scanner;
/**
* @author Liu
* @date 2020/4/12 15:38
*/
public class Test17 {
public static void main(String[] args) {
System.out.println("请输入一个三位整数：");
Scanner sc = new Scanner(System.in);
int s=sc.nextInt();
if (s >= 100 || s < 100) {
int a1 = s / 100;
int b1 = (s % 100) / 10;
int c1 = s % 10;
int s1 = (a1 * a1 * a1) + (b1 * b1 * b1) + (c1 * c1 * c1);
if (s == s1) {
System.out.println("" + s + "是水仙花数");
} else {
System.out.println("" + s + "不是水仙花数");
}
}else{
System.out.println("请输入一个三位整数");
}
}
}
1.5 循环结构
概述
循环，即事物周而复始的变化。循环结构指的是，使一部分代码按照次数或一定的条件反复执行的一种代码结构. 有些时候, 我们想代码是在满足某些条件的情况下, 重复(循环)执行的, 就需要用到循环结构了.
例如: 打印100次HelloWorld. 如果不用循环实现的话, 输出语句我们就需要写100次, 我们发现这样做是非常繁琐的. 于是, 我们可以通过循环来优化它.
组成
1.初始化条件
假设用int类型的变量x记录循环次数,x从1开始数, 数到100刚好100次, 1在这里充当的角色就是: 初始化条件
2.判断条件
变量x从1开始数, 数到100结束. 即: x <= 100, 这就是判断条件, 用来决定循环是否继续执行的
3.循环体
指的是需要重复执行的代码, 例如: System.out.println("Hello World!");
分类
1.for循环
一般适用于循环次数固定的情况
2.while循环
一般适用于循环次数不固定的情况
3.do.while循环
我们在实际开发中, 基本不用. 适用于先执行一次, 然后判断的情况
1.5.1 for循环
for循环是我们在实际开发中应用到的最多的循环, 它一般适用于循环次数固定的情况
格式
for(初始化条件1; 判断条件2; 控制条件3) {
//循环体4;
}
解释:
1.初始化条件: 用来记录 循环的初始状态的. 即: 从哪开始循环.
2.判断条件: 用来决定循环是否继续执行的, 条件成立, 则循环继续执行, 条件不成立, 整个循环就结束了.
3.控制条件: 用来控制初始化条件变化的, 一般是每循环一次, 初始化条件+1.
4.循环体: 需要用来重复做的事情(代码).
执行流程
1.先执行初始化条件
2.然后执行判断条件, 看其结果是true, 还是false
3.如果是false, 则整个循环结束
4.如果是true, 则执行循环体
5.执行控制条件
6.返回第2步, 继续往下重复执行
简单理解:
1.第一次执行: 1, 2, 4, 3. 假设判断条件成立
2.重复执行: 2, 4, 3.
3.最后一次执行: 2 判断条件不成立, 循环结束
图解
案例一：for循环入门
需求
通过for循环, 打印10次"Hello World!"
参考代码
package com.company;
/**
* @author Liu
* @date 2020/4/14 8:57
*/
public class LianXi01 {
public static void main(String[] args) {
for (int i = 0 ; i < 10 ; i++){
System.out.println("Hello World!");
}
}
}
案例二: 打印数字
需求
1.通过for循环, 打印1~5之间的数字
2.通过for循环, 打印5~1之间的数字
参考代码
package com.company;
/**
* @author Liu
* @date 2020/4/14 8:59
*/
public class LianXi02 {
public static void main(String[] args) {
// 通过for循环, 打印1~5之间的数字
for ( int i = 1; i <= 5; i++){
System.out.println(i);
}
// 通过for循环, 打印5~1之间的数字
for (int i = 5; i > 0; i--){
System.out.println(i);
}
}
}
案例三: 求和案例
需求
通过for循环, 获取1 ~ 5之间的数字之和
参考代码
package com.company;
/**
* @author Liu
* @date 2020/4/14 9:03
*/
public class LianXi03 {
public static void main(String[] args) {
// 通过for循环, 获取1 ~ 5之间的数字之和.
int sum = 0;
for ( int i = 1; i <= 5; i++){
sum = sum+ i;
}
System.out.println(sum);
}
}
细节: 求和变量必须定义到for循环的外边, 如果定义到for循环的内容, 则每次循环都会被重置
案例四: 求偶数和
需求
求1-100之间的偶数和，并把求和结果打印到控制台上
参考代码
package com.company;
/**
* @author Liu
* @date 2020/4/14 9:08
*/
public class LianXi04 {
public static void main(String[] args) {
//求1-100之间的偶数和，并把求和结果打印到控制台上
int sum = 0;
for (int i = 1; i <= 100; i++){
if (i % 2 == 0){
sum += i;
}
}
System.out.println(sum);
}
}
案例五: 获取水仙花数
需求
获取到所有的水仙花数, 并将结果打印到控制台上
解释:
水仙花数是一个3位数的整数.
该数字的各个位数立方和相加等于它本身.
例如: 153就是水仙花数, 153 = 1 * 1 * 1 + 5 * 5 * 5 + 3 * 3 * 3 = 153
参考代码
package com.company;
/**
* @author Liu
* @date 2020/4/14 9:12
*/
public class ForLianXi05 {
public static void main(String[] args) {
//获取到所有的水仙花数, 并将结果打印到控制台上
int ge,shi,bai;
for(int i = 100;i < 1000; i++){
ge = i % 10;
shi = i % 100 / 10;
bai = i /100;
if (i == ge*ge*ge +shi*shi*shi + bai*bai*bai){
System.out.println(i);
}
}
}
}
案例六: 计数思想
需求
统计所有水仙花数的个数, 并将其打印到控制台上
参考代码
package com.company;
/**
* @author Liu
* @date 2020/4/14 9:18
*/
public class ForLianXi06 {
public static void main(String[] args) {
//统计所有水仙花数的个数, 并将其打印到控制台上
int ge,shi,bai;
int count = 0;
for(int i = 100;i < 1000; i++){
ge = i % 10;
shi = i % 100 / 10;
bai = i /100;
if (i == ge*ge*ge +shi*shi*shi + bai*bai*bai){
count += 1;
System.out.println(i);
}
}
System.out.println("水仙花的个数为"+count+"");
}
}
案例七: 求和 + 计数
需求
获取1 - 100之间的奇数和, 以及奇数的个数
参考代码
package com.company;
/**
* @author Liu
* @date 2020/4/14 9:25
*/
public class ForLianXi07 {
public static void main(String[] args) {
//获取1 - 100之间的奇数和, 以及奇数的个数
int sum = 0;
int count = 0;
for(int i = 1;i <= 100;i++){
if (i % 2 == 1){
sum += i;
count += 1;
}
}
System.out.println("1 - 100之间的奇数和:"+ sum);
System.out.println("奇数的个数:"+count);
}
}
案例八: 换行输出
需求
把1~100之间的数字, 按照6个一行的格式进行输出
参考代码
package com.company;
/**
* @author Liu
* @date 2020/4/14 9:30
*/
public class ForLianXi08 {
public static void main(String[] args) {
//把1~100之间的数字, 按照6个一行的格式进行输出
int count = 0;
for (int i = 1; i <= 100; i++) {
System.out.print(i+"\t");
count += 1;
if (count % 6 == 0) {
System.out.println();
}
}
}
}
1.5.2 while循环
while循环也是我们在实际开发中应用到的比较多的循环, 它一般适用于循环次数不固定的情况
格式
初始化条件1;
while(判断条件2) {
//循环体3;
//控制条件4;
}
解释:
1.初始化条件: 用来记录 循环的初始状态的. 即: 从哪开始循环.
2.判断条件: 用来决定循环是否继续执行的, 条件成立, 则循环继续执行, 条件不成立, 整个循环就结束了.
3.控制条件: 用来控制初始化条件变化的, 一般是每循环一次, 初始化条件+1.
4.循环体: 需要用来重复做的事情(代码).
执行流程
1.先执行初始化条件
2.然后执行判断条件, 看其结果是true, 还是false
3.如果是false, 则整个循环结束
4.如果是true, 则执行循环体
5.执行控制条件
6.返回第2步, 继续往下重复执行
简单理解:
第一次执行: 1, 2, 3, 4. 假设判断条件成立
重复执行: 2, 3, 4.
最后一次执行: 2 判断条件不成立, 循环结束
图解
案例一: while循环入门
需求
在控制台打印10次HelloWorld
参考代码
package com.company;
/**
* @author Liu
* @date 2020/4/14 9:43
*/
public class WhileLianXi01 {
public static void main(String[] args) {
//在控制台打印10次HelloWorld
int i = 0;
while(i < 10){
System.out.println("HelloWorld");
i++;
}
}
}
案例二: 求和
需求
获取1~100之间所有偶数和, 并将结果打印到控制台上
参考代码
package com.company;
/**
* @author Liu
* @date 2020/4/14 9:46
*/
public class WhileLianXi02 {
public static void main(String[] args) {
//获取1~100之间所有偶数和, 并将结果打印到控制台上
int i = 1;
int sum = 0;
while(i <= 100){
if(i % 2 == 0){
sum += i;
}
i++;
}
System.out.println(sum);
}
}
案例三: 珠穆朗玛峰
需求
1.已知世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米).
2.假如我有一张足够大的纸，它的厚度是0.1毫米.
3.请问，我折叠多少次，可以折成珠穆朗玛峰的高度?
即: 纸张的厚度 >= 珠穆朗玛峰的高度
参考代码
package com.company;
/**
* @author Liu
* @date 2020/4/14 9:50
*/
public class WhileLianXi03 {
public static void main(String[] args) {
//已知世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米).
//假如我有一张足够大的纸，它的厚度是0.1毫米.
//请问，我折叠多少次，可以折成珠穆朗玛峰的高度?
//即: 纸张的厚度 >= 珠穆朗玛峰的高度
double weight = 0.1;
int hight = 8844430;
int count = 0;
while(weight <= hight){
weight *= 2;
count++;
}
System.out.println("需要折叠"+count+"次");
}
}
1.5.3 do.while循环
do.while循环在实际开发中应用到的并不是特别多, 所以我们简单的了解下它的用法即可
格式
初始化条件;
do {
循环体;
控制条件;
} while(判断条件);
解释:
1.初始化条件: 用来记录 循环的初始状态的. 即: 从哪开始循环
2.判断条件: 用来决定循环是否继续执行的, 条件成立, 则循环继续执行, 条件不成立, 整个循环就结束了
3.控制条件: 用来控制初始化条件变化的, 一般是每循环一次, 初始化条件+1
4.循环体: 需要用来重复做的事情(代码)
执行流程
1.先执行初始化条件
2.再执行循环体
3.再执行控制条件
4.执行判断条件, 看其结果是true还是false
5.如果是false, 则整个循环结束
6.如果是true, 则返回第2步重复往下执行
简单理解:
第一次执行: 1, 2, 3, 4. 假设判断条件成立
重复执行: 2, 3, 4.
最后一次执行: 2 判断条件不成立, 循环结束
图解
案例: 打印HelloWorld
需求
通过do.while循环, 在控制台打印10次Hello World
参考代码
package com.company;
/**
* @author Liu
* @date 2020/4/14 10:01
*/
public class DoWhileLianXi01 {
public static void main(String[] args) {
//通过do.while循环, 在控制台打印10次Hello World!
int i = 1;
do {
System.out.println("HelloWorld");
i++;
}while(i <= 10);
}
}
1.5.4 循环扩展
三种循环之间的区别
do.while循环和其他两个循环之间的区别
do.while循环是先执行一次, 后判断
而其他两个循环都是先执行判断条件, 然后决定是否执行循环体
for循环和其他两个循环之间的区别
for循环执行结束后, 初始化条件就不能继续使用了
而其他两个循环执行结束后, 初始化条件还可以继续使用
死循环
概述
所谓的死循环指的是永不会结束的循环, 也就是循环的判断条件永远为true
在后期的开发中，会出现使用死循环的场景，例如：我们需要读取用户输入的输入，但是用户输入多少数据我们并不清楚，也只能使用死循环，当用户不想输入数据了，就可以结束循环了，如何去结束一个死循环呢，就需要使用到跳出语句了。
分类
在Java中, 死循环的写法格式主要有以下3种:
1.for(;;) { }
2.while(true){ }
3.do { } while(true)
参考代码
public class DeadLoop {
public static void main(String[] args) {
/*for(;;) {
System.out.println("Hello World!");
}*/
/*while(true) {
System.out.println("Hello World!");
}*/
do {
System.out.println("Hello World!");
} while(true);
}
}
2.关系运算符
2.1 概述
关系运算符就是用来描述两个变量或者常量之间的关系主要分为以下6种:
符号
说明
==
a==b，判断a和b的值是否相等，成立为true，不成立为false
!=
a!=b，判断a和b的值是否不相等，成立为true，不成立为false
>
a>b，判断a是否大于b，成立为true，不成立为false
>=
a>=b，判断a是否大于等于b，成立为true，不成立为false
<
a
<=
a<=b，判断a是否小于等于b，成立为true，不成立为false
2.2 注意事项
关系运算符的结果都是boolean类型，要么是true，要么是false
千万不要把==写成了=, 否则结果可能不是你想要的
2.3 案例
需求
1.定义两个int类型的变量a和b, 分别赋值为10和5
2.通过关系运算符比较这两个变量之间的关系, 并打印结果
参考代码
public class Demo11 {
public static void main(String[] args) {
//定义两个int类型的变量a和b, 分别赋值为10和5.
int a = 10;
int b = 5;
//通过`关系运算符`比较这两个变量之间的关系, 并打印结果.
System.out.println(a > b);
System.out.println(5 >= 5);
System.out.println(a < b);
System.out.println(5 <= 5);
System.out.println(a != b);
System.out.println(a == b);
System.out.println(a = b);
//关系运算符的最终结果是boolean类型, 所以我们也可以用boolean类型的变量接收.
boolean flag = 10 < 5;
System.out.println(flag);
}
}
3.逻辑运算符
3.1 概述
逻辑运算符是用来判断并且, 或者, 除非等逻辑关系的符号
该符号两端一般连接值为布尔类型的关系表达式
例如: 某企业招工, 要求年龄必须在 20 ~ 65岁之间
3.2 分类
注意: 假设下表中的a和b, 都是boolean类型的值
小技巧:
对一个布尔数据, 偶数次取反, 该数据值不变
!true = false
3.3 示例: 逻辑运算符入门
需求
1.定义三个int类型的变量a, b, c, 它们的初始化值分别为10, 20, 30.
2.通过上述的三个变量, 演示各个逻辑运算符
参考代码
package com.company;
/**
* @author Liu
* @date 2020/4/14 10:09
*/
public class LuoJiLianxi01 {
public static void main(String[] args) {
//定义三个int类型的变量a, b, c, 它们的初始化值分别为10, 20, 30.
//通过上述的三个变量, 演示各个逻辑运算符.
int a = 10, b = 20, c = 30;
//&: 逻辑与, 并且的意思, 有false则整体为false.
//相当于: 班长找女朋友, 要求长得漂亮, 并且身材好.
System.out.println((a > b) & (a > c)); //false & false
System.out.println((a < b) & (a > c)); //true & false
System.out.println((a > b) & (a < c)); //false & true
System.out.println((a < b) & (a < c)); //true & true
System.out.println("-----------------");
//|: 逻辑或, 或者的意思, 有true则整体为true.
//相当于: 降低条件了, 要么长得漂亮, 要么身材好.
System.out.println((a > b) | (a > c)); //false | false
System.out.println((a < b) | (a > c)); //true | false
System.out.println((a > b) | (a < c)); //false | true
System.out.println((a < b) | (a < c)); //true | true
System.out.println("-----------------");
//!: 逻辑非, 取反的意思
//相当于: 只要不是男的就行.
System.out.println(!(a > b)); //!false
System.out.println(!(a < b)); //!true
System.out.println("-----------------");
//逻辑异或, 异同的意思, 相同为false, 不同为true.
//相当于: 最后还是找了个男的, 但是领不了证.
//法律规定: 一夫一妻, 一男一女, 必须是异性才能领证.
System.out.println((a > b) ^ (a > c)); //false ^ false
System.out.println((a < b) ^ (a > c)); //true ^ false
System.out.println((a > b) ^ (a < c)); //false ^ true
System.out.println((a < b) ^ (a < c)); //true ^ true
}
}
3.4 短路逻辑运算符
在实际开发中, 并且, 或者这样的操作是非常多的, 但是上述的&(逻辑与), !(逻辑或)运算符没有短路效应, 所以效率相对较低, 针对这种情况, 我们可以使用&&(短路与), ||(短路或)来优化
3.4.1 格式
3.4.2 解释
在短路与运算中，只要有一个表达式的值为false，那么结果就可以判定为false了，没有必要将所有表达式的值都计算出来，短路与运算符就有这样的效果，可以提高效率。
同理在短路或运算中，一旦发现值为true，右边的表达式将不再参与运算。
3.4.3 短路和非 短路的区别
+逻辑与 和 短路与之间的区别
逻辑与&(也叫单与): 无论左边真假，右边都要执行。
短路与&&(也叫双与): 如果左边为真，右边执行；如果左边为假，右边不执行。
逻辑或 和 短路或之间的区别
逻辑或|(也叫单或): 无论左边真假，右边都要执行。
短路或||(也叫双或): 如果左边为假，右边执行；如果左边为真，右边不执行。
记忆: 在实际开发中, 我们用的最多的逻辑运算符就是: &&, ||, !
3.4.4案例
package com.company;
/**
* @author Liu
* @date 2020/4/14 10:11
*/
public class LuoJiLianxi02 {
public static void main(String[] args) {
//1. 定义两个int类型的变量a和b, 初始化值分别为: 2, 5
int a = 2, b = 5;
//2. 演示逻辑与(&)
/* System.out.println((a++ > 2) & (b++ < 7)); //两个表达式都会执行.
System.out.println(a);
System.out.println(b);*/
System.out.println("------------------");
//3. 演示短路与(&&)
System.out.println((a++ > 2) && (b++ < 7)); //左边表达式结果为false, 右边不执行.
System.out.println(a);
System.out.println(b);
}
}
4.三元运算符
4.1 概述
三元运算符也叫三目运算符，即由三部分组成，格式如下：
(关系表达式) ? 表达式1：表达式2；
4.2 执行流程
1.先执行关系表达式, 看其结果是true还是false.
2.如果是true, 则执行表达式1
3.如果是false, 则执行表达式2
4.3案例一: 入门案例
需求
1.定义两个int类型的变量a. b, 初始化值分别为10, 20
2.通过三元运算符, 获取变量a和b的最大值.
3.将结果(最大值)打印到控制台上.
参考代码
package com.company;
/**
* @author Liu
* @date 2020/4/14 10:14
*/
public class LuoJiLianxi03 {
public static void main(String[] args) {
//定义两个int类型的变量a. b, 初始化值分别为10, 20
//通过三元运算符, 获取变量a和b的最大值.
//将结果(最大值)打印到控制台上.
//(关系表达式) ? 表达式1：表达式2；
int a = 10;
int b = 20;
int max = a < b ? b : a;
System.out.println(max);
}
}
4.4 案例二: 判断老虎体重
需求
动物园里有两只老虎，已知两只老虎的体重分别为180kg、200kg，请用程序实现判断两只老虎的体重是否相同。
参考代码
package com.company;
/**
* @author Liu
* @date 2020/4/14 10:19
*/
public class LuoJiLianxi04 {
public static void main(String[] args) {
//动物园里有两只老虎，已知两只老虎的体重分别为180kg、200kg，
// 请用程序实现判断两只老虎的体重是否相同
int a = 180;
int b = 200;
boolean flag = a == b ? true : false;
System.out.println(flag);
}
}
4.5 案例三: 获取和尚的最高身高
需求
1.一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm.
2.请用程序实现获取这三个和尚的最高身高。
参考代码
package com.company;
/**
* @author Liu
* @date 2020/4/14 10:24
*/
public class LuoJiLianxi05 {
public static void main(String[] args) {
//一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm
//请用程序实现获取这三个和尚的最高身高
int a = 150;
int b = 210;
int c = 165;
int i = a > b ? a : b;
int max = i > c ? i : c;
System.out.println(max);
}
}
5.键入
5.1 概述
之前我们涉及到的数据都是写死的, 固定的数据, 这样做用户体验并不好, 我们就想着, 能不能让用户录入数据, 我们通过特定的代码来接收, 这样做就非常好玩了, 针对于这种情况, 我们可以通过键盘录入来实现
即: Java中键盘录入功能指的就是Scanner类, 我们可以通过它的一些方法, 来获取用户录入的数据
5.2 使用步骤
1.导包 包就是文件夹
注意:
Scanner类是java.util包下的类, 使用之前必须要先导包.
导包的语句是定义在类的上面的, 格式如下:
import java.util.Scanner;
2.创建Scanner类的对象, 格式为:
//暂时先理解为固定格式, 也就是必须这么写.
Scanner sc = new Scanner(System.in);
3.通过Scanner类的nextInt()方法接收用户录入的数据
int a = sc.nextInt();
5.3 案例一: Scanner入门
需求
提示用户录入他/她的年龄.
通过键盘录入功能, 接收用户录入的年龄.
将用户录入的数据(年龄)打印到控制台上.
参考代码
package com.company;
import java.util.Scanner;
/**
* @author Liu
* @date 2020/4/14 10:29
*/
public class JianRuLianXi01 {
public static void main(String[] args) {
//提示用户录入他/她的年龄.
System.out.println("请输入年龄：");
//通过键盘录入功能, 接收用户录入的年龄.
Scanner scanner = new Scanner(System.in);
int age = scanner.nextInt();
//将用户录入的数据(年龄)打印到控制台上.
System.out.println(age);
}
}
5.4 案例二: 键盘录入版和尚身高
需求
提示用户录入第一个和尚的身高, 并接收
提示用户录入第二个和尚的身高, 并接收
提示用户录入第三个和尚的身高, 并接收.
通过三元运算符, 获取三个和尚中身高最矮的那个和尚的身高.
将结果(最低身高)打印到控制台上.
参考代码
package com.company;
import java.util.Scanner;
/**
* @author Liu
* @date 2020/4/14 10:34
*/
public class JianRuLianXi02 {
public static void main(String[] args) {
//提示用户录入第一个和尚的身高, 并接收
System.out.println("请输入第一个和尚的身高：");
Scanner scanner = new Scanner(System.in);
int a = scanner.nextInt();
//提示用户录入第二个和尚的身高, 并接收
System.out.println("请输入第一个和尚的身高：");
Scanner scanner1 = new Scanner(System.in);
int b = scanner1.nextInt();
//提示用户录入第三个和尚的身高, 并接收.
System.out.println("请输入第一个和尚的身高：");
Scanner scanner2 = new Scanner(System.in);
int c = scanner2.nextInt();
//通过三元运算符, 获取三个和尚中身高最矮的那个和尚的身高.
int i = a > b ? a : b;
int max = i > c ? i : c;
//将结果(最低身高)打印到控制台上.
System.out.println(max);
}
}
6. IDEA常用快捷键
快捷键
功能
Alt+Enter
导入包，自动修正代码
Ctrl+Y
删除光标所在行
Ctrl+D
复制光标所在行的内容，插入光标位置下面
Ctrl+Alt+L
格式化代码
Ctrl+/
单行注释
Ctrl+Shift+/
选中代码注释，多行注释，再按取消注释
Alt+Shift+上下箭头/
移动当前代码行
7.练习
7.1 练习一
需求
小明左、右手中分别拿两张纸牌(比如：黑桃10和红桃8，数字10和8可通过键盘录入)，要求编写代码交换小明手中的牌
参考代码
package com.company;
import java.util.Scanner;
/**
* @author Liu
* @date 2020/4/12 15:45
*/
public class Test18 {
public static void main(String[] args) {
System.out.println("请输入小明左手拿的纸牌：");
Scanner sc = new Scanner(System.in);
int a=sc.nextInt();
System.out.println("请输入小明右手拿的纸牌：");
Scanner scc = new Scanner(System.in);
int b=scc.nextInt();
System.out.println("互换前小明手中的纸牌：");
System.out.println("小明左手拿的纸牌："+a);
System.out.println("小明右手拿的纸牌："+b);
int c = b;
int d = a;
System.out.println("互换后小明手中的纸牌：");
System.out.println("小明左手拿的纸牌："+c);
System.out.println("小明右手拿的纸牌："+d);
}
}
练习二
需求
定义一个int类型的变量,初始化值为123,求这个数的个位,十位,百位分别是多少?
参考代码
public class Task01 {
public static void main(String[] args) {
//1.定义一个变量，值为123
int n = 123;
//2.获取该数字中个位、十位、百位的数字
// 个位： 数字 % 10
int ge = n % 10;
// 十位： 数字 / 10 % 10;
int shi = n / 10 % 10;
// 百位： 数字 / 100 % 10;
int bai = n /100 % 10;
//3.打印结果
//123的个位是3,十位是2,百位是1
System.out.println(n + "的个位是"+ ge +",十位是"+ shi +",百位是" + bai);
}
}
练习三
需求
键盘录入一个三位数字,输出该三位数字是否是水仙花数字?
水仙花数字要求: 指的是一个三位数，个位、十位、百位的数字立方和等于原数
例如 153 3*3*3 + 5*5*5 + 1*1*1 = 27 + 125 + 1 = 153
参考代码
public class Task03 {
public static void main(String[] args) {
//1.创建键盘录入对象
Scanner sc = new Scanner(System.in);
//2.获取一个int数字
System.out.println("请输入一个三位整数");
int num = sc.nextInt();
//3.获取个位,十位,百位
int ge = num%10;
int shi = num/10%10;
int bai = num/100%10;
//4.求个位,十位,百位的立方和
int sum = ge*ge*ge + shi*shi*shi + bai*bai*bai;
//5.利用三元运算符求立方和是否等于该数字本身
boolean flag = (sum==num)?true:false;
//6.打印结果
System.out.println(num+"是水仙花数字吗? "+flag);
}
}
练习四
需求
按照从大到小的顺序输出四位数中的个位+百位=十位+千位(3553,2332,1166,8228,3773)的数字及个数.
每行输出5个满足条件的数，之间用空格分隔
如：9999 9988 9977 9966 9955
参考代码
package com.company;
/**
* @author Liu
* @date 2020/4/14 10:50
*/
public class Task01 {
public static void main(String[] args) {
//按照从大到小的顺序输出四位数中的个位+百位=十位+千位(3553,2332,1166,8228,3773)的数字及个数.
//每行输出5个满足条件的数，之间用空格分隔
//如：9999 9988 9977 9966 9955
int count = 0;
for (int i = 9999 ; i >= 1000;i--){
int ge = i % 10;
int shi = (i % 100) / 10;
int bai = (i % 100) / 100;
int qian = i / 1000;
if (ge + bai == shi + qian ){
count += 1;
if (count <= 5){
System.out.print(i +" ");
}
}
}
}
}
练习五
需求
从键盘上录入一个大于100的三位数,求出100到该数字之间满足如下要求的数字之和, 要求如下:
数字的个位数不为7;
数字的十位数不为5;
数字的百位数不为3;
参考代码
package com.company;
import java.util.Scanner;
/**
* @author Liu
* @date 2020/4/14 10:50
*/
public class Task02 {
public static void main(String[] args) {
//从键盘上录入一个大于100的三位数,求出100到该数字之间满足如下要求的数字之和, 要求如下:
//数字的个位数不为7;
//数字的十位数不为5;
//数字的百位数不为3;
System.out.println("请输入一个大于100的三位数：");
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
for (int i = 100; i <= n ; i++){
int ge = i % 10;
int shi = (i % 100) / 10;
int bai = i / 100;
if (ge != 7 && shi != 5 && bai != 3){
System.out.println(i);
}
}
}
}
扫一扫
4086
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
