此资料是根据黑马程序员Java零基础视频教程提供的笔记进行修改而成,仅用于个人学习。
学习视频:https://www.bilibili.com/video/BV17F411T7Ao/?p=39&vd_source=a0fb36c5a191d7be68335738a8b342a2
1. 流程控制语句
在一个程序执行的过程中,各条语句的执行顺序对程序的结果是有直接影响的。所以,我们必须清楚每条语句的执行流程。而且,很多时候要通过控制语句的执行顺序来实现我们想要的功能。
1.1 流程控制语句分类
-
顺序结构
-
判断和选择结构(if, switch)
-
循环结构(for, while, do…while)
1.2 顺序结构
顺序结构是程序中最简单最基本的流程控制,没有特定的语法结构,按照代码的先后顺序,依次执行,程序中大多数的代码都是这样执行的。
顺序结构执行流程图:
示例:
public static void main(String[] args) {
System.out.println("努力做主人喜欢的事");
System.out.println("大小姐驾到!统统闪开!");
System.out.println("凛冬已至,故乡的梅花开了吗");
System.out.println("心怀不惧,方能翱翔于天际");
}
结果:
2. if语句(判断)
2.1 if语句格式1 (如果)
if (关系表达式) {
语句体;
}
执行流程:
①首先计算关系表达式的值
②如果关系表达式的值为true就执行语句体
③如果关系表达式的值为false就不执行语句体
④继续执行后面的语句内容
示例:
public class IfDemo {
public static void main(String[] args) {
System.out.println("开始");
//定义两个变量
int a = 10;
int b = 20;
//需求:判断a和b的值是否相等,如果相等,就在控制台输出:a等于b
if(a == b) {
System.out.println("a等于b"); //不相等,不会执行
}
//需求:判断a和c的值是否相等,如果相等,就在控制台输出:a等于c
int c = 10;
if(a == c) {
System.out.println("a等于c"); //相等,会执行
}
System.out.println("结束");
}
}
结果:
2.1.1 练习1:老丈人选女婿
需求:
键盘录入女婿的酒量,如果大于2斤,老丈人给出回应,否则没有任何回应
代码示例:
//分析:
//1.键盘录入女婿的酒量
Scanner sc = new Scanner(System.in);
System.out.println("请输入女婿的酒量");
int wine = sc.nextInt();//5
//2.对酒量进行一个判断即可
if(wine > 2) {
System.out.println("不错哟,小伙子!");
}
2.1.2 练习2:考试奖励
需求:
键盘录入一个整数,表示小明的考试名次,如果名次为1,小红可以当小明的女朋友了。
代码示例:
//分析:
//1.键盘录入一个整数,表示小明的考试名次
Scanner sc = new Scanner(System.in);
System.out.println("请输入小明的名次");
int rank = sc.nextInt();
//2.对小明的考试成绩进行判断即可
if(rank == 1){
System.out.println("小红成为了小明的女朋友");
}
2.1.3 第一种格式的细节
- 大括号的开头可以另起一行书写,但是建议写在第一行的末尾。
- 如果我们要对一个布尔类型的变量进行判断,不要写==,直接把变量写在小括号中即可。
- 在语句体中,如果只有一句代码,那么大括号可以省略不写。但是难以判定是否是一句代码,所以建议都加上大括号。
- 如果大括号省略了,那么if只能控制距离他最近的那一条语句。
建议:自己不要去写,如果别人这么写了,能看懂即可,所以还是建议加上大括号。
问题:
解决方法:
添上 if 后大括号就不会报错
2.2 if语句格式2 (如果…否则)
格式:
if (关系表达式) {
语句体1;
} else {
语句体2;
}
执行流程:
①首先计算关系表达式的值
②如果关系表达式的值为true就执行语句体
③如果关系表达式的值为false就不执行语句体
④继续执行后面的语句内容
示例:
public class IfDemo02 {
public static void main(String[] args) {
System.out.println("开始");
//定义两个变量
int a = 10;
int b = 20;
//需求:判断a是否大于b,如果是,在控制台输出:a的值大于b,否则,在控制台输出:a的值不大于b
if(a > b) {
System.out.println("a的值大于b"); //不会执行
} else {
System.out.println("a的值不大于b"); //会执行
}
System.out.println("结束");
}
}
结果:
2.2.1 练习1:吃饭
需求:
键盘录入一个整数,表示身上的钱。
如果大于等于100块,就吃网红餐厅。
否则,就吃经济实惠的沙县小吃。
代码示例:
//分析:
//1.键盘录入一个整数。表示身上的钱。
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数表示身上的钱");
int money = sc.nextInt();
//2.对钱进行判断
if(money >= 100){
System.out.println("吃网红餐厅");
}else{
System.out.println("吃经济实惠的沙县小吃");
}
2.2.2 练习2:影院选座
需求:
在实际开发中,电影院选座也会使用到if判断。
假设某影院售卖了100张票,票的序号为1~100。
其中奇数票号坐左侧,偶数票号坐右侧。
键盘录入一个整数表示电影票的票号。
根据不同情况,给出不同的提示:
如果票号为奇数,那么打印坐左边。
如果票号为偶数,那么打印坐右边。
代码示例:
//分析:
//1.键盘录入票号
Scanner sc = new Scanner(System.in);
System.out.println("请输入票号");
int ticket = sc.nextInt();
if(ticket >= 1 && ticket <= 100){
//票号合法
//2.对票号进行判断
if (ticket % 2 == 0) {
//偶数
System.out.println("坐右边");
} else {
//奇数
System.out.println("坐左边");
}
}else{
//票号不合法,增强了程序的健壮性
System.out.println("票号不合法");
}
2.3 if语句格式3 (如果……如果…否则)
格式:
if (关系表达式1) {
语句体1;
} else if (关系表达式2) {
语句体2;
}
…
else {
语句体n+1;
}
执行流程:
①首先计算关系表达式1的值
②如果值为true就执行语句体1;如果值为false就计算关系表达式2的值
③如果值为true就执行语句体2;如果值为false就计算关系表达式3的值
④…
⑤如果没有任何关系表达式为true,就执行语句体n+1。
2.3.1 练习1:考试奖励
需求:
小明快要期末考试了,小明爸爸对他说,会根据他不同的考试成绩,送他不同的礼物,
假如你可以控制小明的得分,请用程序实现小明到底该获得什么样的礼物,并在控制台输出。
分析:
①小明的考试成绩未知,可以使用键盘录入的方式获取值
②由于奖励种类较多,属于多种判断,采用if…else…if格式实现
③为每种判断设置对应的条件
④为每种判断设置对应的奖励
代码示例:
//95~100 自行车一辆
//90~94 游乐场玩一天
//80 ~ 89 变形金刚一个
//80 以下 胖揍一顿
//1.键盘录入一个值表示小明的分数
Scanner sc = new Scanner(System.in);
System.out.println("请输入小明的成绩");
int score = sc.nextInt();
//2.对分数的有效性进行判断
if(score >= 0 && score <= 100){
//有效的分数
//3.对小明的分数进行判断,不同情况执行不同的代码
if(score >= 95 && score <= 100){
System.out.println("送自行车一辆");
}else if(score >= 90 && score <= 94){
System.out.println("游乐场玩一天");
}else if(score >= 80 && score <= 89){
System.out.println("变形金刚一个");
}else{
System.out.println("胖揍一顿");
}
}else{
//无效的分数
System.out.println("分数不合法");
}
2.3.2 练习2:商品的价格
需求:
商场都会有VIP的会员制,根据不同的会员会有不同的折扣。假设商品总价为1000。键盘录入会员级别,并计算出实际支付的钱。
会员1级:打9折。
会员2级:打8折。
会员3级:打7折。
非会员:不打折,要打也是打骨折。
分析:
①定义变量记录总价
②键盘录入会员的级别
③根据级别来计算实际要支付的钱
代码示例:
//1.定义变量记录总价
int price = 1000;
//2.键盘录入会员的级别
Scanner sc = new Scanner(System.in);
System.out.println("请录入会员的级别");
int vip = sc.nextInt();
//3.根据级别来计算实际要支付的钱
if(vip == 1){
System.out.println("实际支付的钱为" + (price * 0.9));//记得打括号
}else if(vip == 2){
System.out.println("实际支付的钱为" + (price * 0.8));
}else if(vip == 3){
System.out.println("实际支付的钱为" + (price * 0.7));
}else{
System.out.println("实际支付的钱为" + price);
}
结果(结果就不是int类型了,有double类型的数据参与计算,int隐式转换为double类型):
2.3.3 练习3:自动驾驶加强版
//1.定义三个变量表示灯的状态
//true 亮 false 灭
boolean isLightGreen = true; //当前是绿灯
boolean isLightYellow = false;
boolean isLightRed = false;
//2.判断
//红灯亮,就停止
//黄灯亮,就减速
//绿灯亮,就行驶
if(isLightGreen){
System.out.println("GoGoGo!!!"); //GoGoGo!!!
}else if(isLightYellow){
System.out.println("slow!!!");
}else if(isLightRed){
System.out.println("stop!!!");
}
3. switch语句 (多重选择)
3.1 格式
switch (表达式) {
case 1:
语句体1;
break;
case 2:
语句体2;
break;
...
default:
语句体n+1;
break;
}
3.2 执行流程
- 首先计算出表达式的值 。
- 其次,和case依次比较,一旦有对应的值,就会执行相应的语句,在执行的过程中,遇到break就会结束。
- 最后,如果所有的case都和表达式的值不匹配,就会执行default语句体部分,然后程序结束掉。
3.3 注意事项
- 表达式必须是整型(byte、short、int)、字符(char、jdk7以后可以String)或枚举量值(jdk5以后可以enum)。
- case后面的常量标号,其类型应与表达式的数据类型相同,不能是变量!!!表示是根据表达式进而计算出的结果,可能在case的标号中找到,标号不允许重复,具有唯一性,(重复编译器会报错)所以,只能选中一个case标号。尽管标号的顺序可以任意的,但从可读性角度而言,标号应按顺序排列。
- break是中断跳转语句,表示在完成相应的case标号规定的操作之后,不继续执行switch语句的剩余部分而直接跳出switch语句之外,继而执行switch结构后面的第一条语句。
- default用于处理所有switch结构的非法操作。当表达式的值与任何一个case都不匹配时,则执行default,相当于if语句里面的else。如果default处于switch语句的最后,那么default后面的break可以省略。
- jdk7加入的新特性可以支持String类型的数据,但是long是不可以的,必须强转为整型(byte、short、int)。
- case后面常量标号的后面和default后面是 冒号 : ,语句体和break后面试分号;,表示语句结尾。
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
byte b = sc.nextByte();
short s = sc.nextShort();
int i = sc.nextInt();
long lo = sc.nextLong();
double d = sc.nextDouble();
float f = sc.nextFloat();
String str = sc.nextLine();
char c = 'T';
switch (b) {
case 1:
}
switch (s) {
case 1:
}
switch (i) {
case 1:
}
/*
switch (lo) { //报错 不能为long类型
case 99999999:
}
switch (d) { //报错 不能为double类型
case 1.23:
}
switch (f) { //报错 不能为float类型
case 1.0:
}
*/
switch (str) {
case "China":
}
switch (c) {
case 'T':
}
}
3.4 switch的扩展知识
3.4.1 default的位置和省略情况
default可以放在任意位置,也可以省略。 default的位置不一定要放在最后,但是习惯上放在最后,可以与前面的case交换位置。省略掉default 。不建议省略,多一个备胎,多一种选择。如果default没有在最后的话,那么里面的break最好要加上,不然也会产生穿透现象。
int number = 100;
switch (number){
// default位置随便,没有要求一定要在最后,但是习惯上放在最后。
default:
System.out.println("number的值不是1,10或者20");
break; //default如果没有在最后的话,这个break尽量要加上,不然会产生穿透现象。
case 1:
System.out.println("number的值为1");
break;
case 10:
System.out.println("number的值为10");
break;
case 20:
System.out.println("number的值为20");
break;
}
3.4.2 case穿透
不写break会引发case穿透现象。直落下降执行,直到遇到break或大括号结束。
首先还是会拿着小括号中表达式的值跟下面每一个case进行匹配。如果匹配上了,就会执行对应的语句体,如果此时发现了break,那么结束整个switch语句。如果没有发现break,那么程序会继续执行下一个case的语句体,一直遇到break或者右大括号为止。
int number = 10;
switch (number){
case 1:
System.out.println("number的值为1");
break;
case 10:
System.out.println("number的值为10");
// break ;
case 20:
System.out.println("number的值为20");
break;
default:
System.out.println("number的值不是1,10或者20");
// break;
}
结果:
3.4.3 switch在JDK12的新特性
用箭头替换掉原来的冒号。如果语句体只有一行代码,则大括号与break可以省略不写
int number = 10;
switch (number) {
case 1 -> {
System.out.println("一"); //这种方法就不用在后面加break了
}
case 2 -> System.out.println("二");
case 3 -> System.out.println("三");
default -> System.out.println("其他");
}
3.4.4 switch和if第三种格式各自的使用场景
当我们需要对一个范围进行判断的时候,用if的第三种格式。如果范围判断也用switch语句的话,那么就需要将每一个值一一列举出来,就非常的麻烦。
当我们把有限个数据列举出来,选择其中一个执行的时候,用switch语句。
比如:
小明的考试成绩,如果用switch,那么需要写100个case,太麻烦了,所以用if简单。
如果是星期,月份,客服电话中0~9的功能选择就可以用switch
3.5 练习:运动计划
-
需求:键盘录入星期数,显示今天的减肥活动。
周一:跑步
周二:游泳
周三:慢走
周四:动感单车
周五:拳击
周六:爬山
周日:好好吃一顿
- 代码示例:
package a01switch选择语句;
import java.util.Scanner;
public class SwitchDemo2 {
public static void main(String[] args) {
//1.键盘录入一个整数表示星期
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数表示星期");
int week = sc.nextInt();
//2.书写一个switch语句去跟week进行匹配
switch (week){
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;
}
}
}
3.6 练习:休息日和工作日
需求:键盘录入星期数,输出工作日、休息日。
(1-5) 工作日,(6-7)休息日。
代码示例:
//分析:
//1.键盘录入星期数
Scanner sc = new Scanner(System.in);
System.out.println("请输入星期");
int week = sc.nextInt();//3
//2.利用switch进行匹配
----------------------------------------------------
利用case穿透简化代码
switch (week){
case 1:
case 2:
case 3:
case 4:
case 5:
System.out.println("工作日");
break;
case 6:
case 7:
System.out.println("休息日");
break;
default:
System.out.println("没有这个星期");
break;
}
----------------------------------------------------
JDK12加强版
switch (week){
case 1,2,3,4,5:
System.out.println("工作日");
break;
case 6,7:
System.out.println("休息日");
break;
default:
System.out.println("没有这个星期");
break;
}
----------------------------------------------------
利用JDK12简化代码书写
switch (week) {
case 1, 2, 3, 4, 5 -> System.out.println("工作日");
case 6, 7 -> System.out.println("休息日");
default -> System.out.println("没有这个星期");
}
3.7 练习:按键服务
在实际开发中,如果我们需要在多种情况下选择其中一个,就可以使用switch语句。
当我们拨打了某些服务电话时,一般都会有按键选择。假设现在我们拨打了一个机票预定电话。
电话中语音提示:
1机票查询
2机票预订
3机票改签
4退出服务
其他按键也是退出服务。请使用switch模拟该业务逻辑。
//分析:
//1.键盘录入一个整数表示我们的选择
Scanner sc = new Scanner(System.in);
System.out.println("请输入您的选择");
int choose = sc.nextInt();
//2.根据选择执行不同的代码
switch(choose){
/*default:
System.out.println("退出服务");
break; 如果这里注释掉break的话,那么他会执行到机票查询,跟case穿透一样*/
case 1:
System.out.println("机票查询");
break;
case 2:
System.out.println("机票预订");
break;
case 3:
System.out.println("机票改签");
break;
default:
System.out.println("退出服务");
// break; 如果default位置处于最后,那么后面的break就可以省略。
}
/*switch (choose) {
case 1 -> System.out.println("机票查询");
case 2 -> System.out.println("机票预订");
case 3 -> System.out.println("机票改签");
//case 4 -> System.out.println("退出服务");
default -> System.out.println("退出服务");
}*/
4. 循环结构
4.1 for循环结构(掌握)
循环语句可以在满足循环条件的情况下,反复执行某一段代码,这段被重复执行的代码被称为循环体语句,当反复执行这个循环体时,需要在合适的时候把循环判断条件修改为false,从而结束循环,否则循环将一直执行下去,形成死循环。
4.1.1 for循环格式
for (初始化语句;条件判断语句;条件控制语句) {
循环体语句;
}
4.1.1.1 格式解释
- 初始化语句: 用于表示循环开启时的起始状态,简单说就是循环开始的时候什么样
- 条件判断语句:用于表示循环反复执行的条件,简单说就是判断循环是否能一直执行下去
- 循环体语句: 用于表示循环反复执行的内容,简单说就是循环反复执行的事情
- 条件控制语句:用于表示循环执行中每次变化的内容,简单说就是控制循环是否能执行下去
4.1.1.2 执行流程
①执行初始化语句
②执行条件判断语句,看其结果是true还是false
如果是false,循环结束
如果是true,继续执行
③执行循环体语句
④执行条件控制语句
⑤回到②继续
4.1.1.3 for循环书写技巧
- 确定循环的开始条件
- 确定循环的结束条件
- 确定循环要重复执行的代码
代码示例:
//1.确定循环的开始条件
//2.确定循环的结束条件
//3.确定要重复执行的代码
//需求:打印5次HelloWorld
//开始条件:1
//结束条件:5
//重复代码:打印语句
for (int i = 1; i <= 5; i++) {
System.out.println("HelloWorld");
}
4.1.2 for循环练习
4.1.2.1 输出数据
- 需求:在控制台输出1-5和5-1的数据
- 示例代码:
public class ForTest01 {
public static void main(String[] args) {
//需求1:打印1-5
//分析:
//开始条件:1
//结束条件:5
for (int i = 1 ; i <= 5; i++){
//第一次循环:i = 1
//第二次循环:i = 2 ……
//i : 1 2 3 4 5
System.out.println(i);
}
//需求2:打印5-1
//分析:
//开始条件: 5
//结束条件:1
for(int i = 5 ; i >= 1 ; i--){
System.out.println(i);
}
}
}
4.1.2.2 求和
- 需求:求1-5之间的数据和,并把求和结果在控制台输出
- 示例代码:
public class ForTest02 {
public static void main(String[] args) {
//求和的最终结果必须保存起来,需要定义一个变量,用于保存求和的结果,初始值为0
int sum = 0;
//从1开始到5结束的数据,使用循环结构完成
for(int i=1; i<=5; i++) {
//将反复进行的事情写入循环结构内部
// 此处反复进行的事情是将数据 i 加到用于保存最终求和的变量 sum 中
sum = sum + i;
/*
sum += i; sum = sum + i;
第一次:sum = sum + i = 0 + 1 = 1;
第二次:sum = sum + i = 1 + 2 = 3;
第三次:sum = sum + i = 3 + 3 = 6;
第四次:sum = sum + i = 6 + 4 = 10;
第五次:sum = sum + i = 10 + 5 = 15;
*/
}
//当循环执行完毕时,将最终数据打印出来
System.out.println("1-5之间的数据和是:" + sum);
}
}
- 本题要点:
- 今后遇到的需求中,如果带有求和二字,请立即联想到求和变量
- 求和变量的定义位置,必须在循环外部,如果在循环内部则计算出的数据将是错误的,涉及到变量的作用范围
4.1.2.3 求偶数和
- 需求:求1-100之间的偶数和,并把求和结果在控制台输出
- 示例代码:
public class ForTest03 {
public static void main(String[] args) {
//求和的最终结果必须保存起来,需要定义一个变量,用于保存求和的结果,初始值为0
int sum = 0;
//对1-100的数据求和与1-5的数据求和几乎完全一样,仅仅是结束条件不同
//IDEA快捷键,100.fori可以快速都出代码
for(int i=1; i<=100; i++) {
//对1-100的偶数求和,需要对求和操作添加限制条件,判断是否是偶数
if(i%2 == 0) {
//偶数取余为0
//sum += i;
sum = sum + i;
}
}
//当循环执行完毕时,将最终数据打印出来
System.out.println("1-100之间的偶数和是:" + sum);
}
}
4.1.2.4 统计次数
需求:
键盘录入两个数字,表示一个范围。
统计这个范围中。
既能被3整除,又能被5整除数字有多少个?
代码示例:
//1.键盘录入两个数字
Scanner sc = new Scanner(System.in);
System.out.println("请录入一个数字表示范围的开始");
int start = sc.nextInt();
System.out.println("请录入一个数字表示范围的结束");
int end = sc.nextInt();
//统计变量
//简单理解:统计符合要求的数字的个数
int count = 0;
//2.利用循环获取这个范围中的每一个数字
//开始条件:start
//结束条件:end
for (int i = start; i <= end; i++) {
//3.对每一个数字进行判断,统计有多少个满足要求的数字
if (i % 3 == 0 && i % 5 == 0) {
// System.out.println(i);
count++;
}
}
System.out.println(count);
4.2 while循环
4.2.1 格式
初始化语句;
while(条件判断语句){
循环体;
条件控制语句;
}
特点:
先判断,再执行。
4.2.2 练习
4.2.2.1 练习1:打印5次HelloWorld
int i = 1;
while(i <= 5){
System.out.println("HelloWorld");
i++;
}
System.out.println(i);
4.2.2.2 练习2:珠穆朗玛峰
需求:
世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米),假如我有一张足够大的纸,它的厚度是0.1毫米。
请问,我折叠多少次,可以折成珠穆朗玛峰的高度?
//1.定义一个变量表示珠穆朗玛峰的高度
int height = 8844430;
//2.定义一个变量表示纸张的厚度
double paper = 0.1;
//定义一个计数器(变量),用来统计折叠的次数
int count = 0;
//3.循环折叠纸张
//只有纸张的厚度 < 穆朗玛峰的高度 循环才继续,否则循环就停止
//坑:只有判断为真,循环才会继续
while(paper < height){
//折叠纸张
paper = paper * 2;
count++;
}
//4.打印一下纸张的厚度
System.out.println(count);//27
4.2.2.3 练习3:判断回文数
需求:
给你一个整数 x 。
如果 x 是一个回文整数,打印 true ,否则,返回 false 。
解释:
回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。
例如,121 是回文,而 123 不是。
分析:
1.定义变量记录整数
2.定义变量记录最终的结果(反过来的数字)
3.利用循环从右往左获取x中的数字并拼接到result当中
//1.定义变量记录整数
int x = 12345;
//把x做一个临时存储,用来最后进行判断
int temp = x;
//2.定义变量记录最终的结果(反过来的数字)
int result = 0;
//3.利用循环从右往左获取x中的数字并拼接到result当中
//while
while(x != 0){
//获取到x最右边的数字
int ge = x % 10;
//获取一次数字之后,那么就要把当前最右边的数字给去掉
x = x / 10;
//拼接到result当中
result = result * 10 + ge;
}
if(result == temp){
System.out.println(temp + "是回文字数");
}
System.out.println(result == temp);
----------------------------------------------------
/*手动输入数字版本*/
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个数:");
int num = sc.nextInt();
//保存输入的数字,因为原来的数会发生变化
int temp = num;
int ret = 0;
while(num != 0){
//得到最右边的数
int ge = num % 10;
//去掉最右边的数
num /= 10;
//下面这个才是是灵魂,组装数据
ret = ret * 10 + ge;
}
if(temp == ret){
System.out.println(temp+"是一个回文数");
}else{
System.out.println(temp+"不是一个回文数");
}
}
4.2.2.4 练习四:求商和余数
需求:
给定两个整数,被除数和除数(都是正数,且不超过int的范围) 。
将两数相除,要求不使用乘法、除法和 % 运算符。
得到商和余数。
分析:
被除数 / 除数 = 商 … 余数
int a = 100;
int b = 10;
100 - 10 = 90
90 - 10 = 80
80 - 10 = 70
70 - 10 = 60
…
10 - 10 = 0 (余数)
//1.定义变量记录被除数
int dividend = 100;
//2.定义变量记录除数
int divisor = 37;
//3.定义一个变量用来统计相减了多少次
int count = 0;
//3.循环 while
//在循环中,不断的用被除数 - 除数
//只要被除数 是大于等于除数的,那么就一直循,环巧妙之处在于用减法来代替除法。
while(dividend >= divisor){
dividend = dividend - divisor;
//只要减一次,那么统计变量就自增一次
count++;
}
//当循环结束之后dividend变量记录的就是余数
System.out.println("余数为:" + dividend);
//当循环结束之后,count记录的值就是商
System.out.println("商为:" + count);
4.3 do…while循环
本知识点了解即可
格式:
初始化语句;
do{
循环体;
条件控制语句;
}while(条件判断语句);
特点:
先执行,再判断。
案例:
*
使用 do While实现循环输入数据
*/
Scanner sc = new Scanner(System.in);
int num = 0;
do {
System.out.print("请输入一个数: ");
num = sc.nextInt();
System.out.println("你当前输入的数字是:"+num);
}while (num != EOF);
结果:
4.4 三种格式的区别
for和while循环,是先判断,再执行。
do…while是先执行,再判断。最少都做了一次。
当知道循环次数或者循环范围的时候,用for循环。
当不知道循环次数,也不知道循环范围,但是知道循环的结束条件时,用while循环。
5. 高级循环
5.1 无限循环(死循环)
概念:
又叫死循环。循环一直停不下来。
5.1.1 for格式
for(;;){
System.out.println("循环执行一直在打印内容");
}
解释:
初始化语句可以空着不写,表示循环之前不定义任何的控制变量。
条件判断语句可以空着不写,如果不写,默认表示true,循环一直进行。
条件控制语句可以空着不写,表示每次循环体执行完毕后,控制变量不做任何变化。
5.1.2 while格式
while(true){
//为真一直循环
System.out.println("循环执行一直在打印内容");
}
解释:
小括号里面就不能省略了,true一定要写出来,否则代码会报错。
5.1.3 do…while格式
do{
System.out.println("循环执行一直在打印内容");
}while(true);
解释:
小括号里面就不能省略了,true一定要写出来,否则代码会报错。
5.1.4 无限循环的注意事项
- 最为常用的格式:while
- 无限循环下面不能再写其他代码了,因为永远执行不到。
5.2 条件控制语句
- break
- continue
5.2.1 break
不能单独存在的。可以用在switch和循环中,表示结束,跳出的意思。
代码示例:
//1.吃1~5号包子;结束整个循环
for (int i = 1; i <= 5; i++) {
System.out.println("在吃第" + i + "个包子");
//2.吃完第三个的时候就不吃了
if(i == 3){
System.out.println("吃了3个包子,我已经吃饱了,不想吃了。");
break;//结束整个循环。
}
}
5.2.2 continue
不能单独存在的。只能存在于循环当中。
表示:跳过本次循环,继续执行下次循环。
代码示例:
//1.跳过某一次循环
for (int i = 1; i <= 5; i++) {
if(i == 3){
//第三个包子里面有虫不能吃。
//结束本次循环,继续下次循环。
continue;
}
System.out.println("小老虎在吃第" + i + "个包子");
}
5.3 Random随机数
Random跟Scanner一样,也是Java提前写好的类,我们不需要关心是如何实现的,只要直接使用就可以了。
使用步骤:
- 导包
import java.util.Random;
导包的动作必须出现在类定义的上边。
- 创建对象
Random r = new Random ();
上面这个格式里面,只有r是变量名,可以变,其他的都不允许变。
-
生成随机数
int number = r.nextInt(随机数的范围);
上面这个格式里面,只有number是变量名,可以变,其他的都不允许变。
随机数范围的特点:从0开始,不包含指定值。比如:参数为10,生成的范围 [0,10), 包头不包尾,包左不包右。 -
确定区间
如果后面加了一个数,那么这个数就是区间的左值。如果没有加的话闭区间的左值就是0。
如果后面加了一个数,那么开区间的右值就是这个数加上括号里面的。
例如:r.nextInt(99) + 103; 因为99+103=202,所以表示区间是:[103,202), 即[103,201]。
代码示例:
//1.导包
import java.util.Random;
public class RandomDemo1 {
public static void main(String[] args) {
//2.创建对象
Random r = new Random();
//3.生成随机数
int number = r.nextInt(100);//包左不包右,包头不包尾 [0,99]
System.out.println(number);
}
}
5.4 训练一:逢七过
需求:
朋友聚会的时候可能会玩一个游戏:逢7过
游戏规则:从任意一个数字开始报数,当你要报的数字是包含7或者是7的倍数时都要说过:过
使用程序在控制台打印出1-100之间的满足逢七必过规则的数据
举例:
1 2 3 4 5 6 过 8 9 10 11 12 13 过 15 16 过 18 …
代码示例:
/*朋友聚会的时候可能会玩一个游戏:逢7过
游戏规则:从任意一个数字开始报数,当你要报的数字是包含7或者是7的倍数时都要说过:过
需求:使用程序在控制台打印出1-100之间的满足逢七必过规则的数据*/
//分析:
//个位7 十位7 7倍数
//1 2 3 4 5 6 过 8 9 10 11 12 13 过 15 16 过 18 19 20 过....
//69 过 过 过 过 过 过... 80
//1.得到1~100之间的每一个数字
//开始:1
//结束:100
for (int i = 1; i <= 100; i++) {
//2.判断每一个数字,如果符合规则,就打印过,如果不符合规则就打印真实的数字
//i % 10 == 7 表示个位数是7
// i / 10 % 10 == 7 表示十位数是7
//i % 7 == 0 表示7的倍数
if(i % 10 == 7 || i / 10 % 10 == 7 || i % 7 == 0){
System.out.println("过");
continue;
}
System.out.println(i);
}
5.5 训练二:平方根
需求:
键盘录入一个大于等于2的整数 x ,计算并返回 x 的 平方根 。结果只保留整数部分 ,小数部分将被舍去 。
代码示例:
/*需求:键盘录入一个大于等于2的整数 x ,计算并返回 x 的 平方根 。
结果只保留整数部分 ,小数部分将被舍去 。*/
//分析:
//平方根 16的平方根4
// 4的平方根2
// 10
// 1 * 1 = 1 < 10
// 2 * 2 = 4 < 10
// 3 * 3 = 9 < 10
// 4 * 4 = 16 > 10
//推断:10的平方根是在3~4之间。
// 20
// 1 * 1 = 1 < 20
// 2 * 2 = 4 < 20
// 3 * 3 = 9 < 20
// 4 * 4 = 16 < 20
// 5 * 5 = 25 > 20
//推断:20的平方根是在4~5之间。
//在代码当中
//从1开始循环,拿着数字的平方跟原来的数字进行比较
//如果小于的,那么继续往后判断
//如果相等,那么当前数字就是平方根
//如果大于的,那么前一个数字就是平方跟的整数部分
//1.键盘录入一个整数
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数");
int number = sc.nextInt();
//2.从1开始循环判断
//开始:1 结束: number
for (int i = 1; i <= number; i++) {
//这里还能优化一下:i <= number/2,循环次数直接少一半
//用i * i 再跟number进行比较
if(i * i == number){
System.out.println(i + "就是" + number + "的平方根");
//一旦找到了,循环就可以停止了,后面的数字就不需要再找了,提高代码的运行效率。
break;
}else if(i * i > number){
System.out.println((i - 1) + "就是" + number + "平方根的整数部分");
break;
}
}
5.6 训练三:判断是否为质数
需求:
键盘录入一个正整数 x ,判断该整数是否为一个质数。
质数:
如果一个整数只能被1和本身整除,那么这个数就是质数。否则这个数叫做合数。
代码示例:
//7 = 1 * 7 所以7是质数
//8 = 1 * 8 = 2 * 4 ,所以8是合数
//分析:
//1.键盘录入一个正整数
//number
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个正整数");
int number = sc.nextInt();//9
//定义一个变量,表示标记
//标记着number是否为一个质数
//true: 是一个质数
//false : 不是一个质数
//表示最初就认为number是一个质数
boolean flag = true;
//2.判断
//写一个循环,从2开始判断,一直判断到number-1为止
//看这个范围之内,有没有数字可以被number整除
for (int i = 2; i < number; i++) {
//范围区间[2,number-1]
//i 依次表示这个范围之内的每一个数字
//看number是否能被i整除就可以了
if(number % i == 0){
// 9 % 2 = 1
flag = false;
//System.out.println(number + "不是一个质数");
break;
}/*else{
System.out.println(number + "是一个质数");
}*/
}
//只有当这个循环结束了,表示这个范围之内所有的数字都判断完毕了
//此时才能断定number是一个质数
if(flag){
System.out.println(number + "是一个质数");
}else{
System.out.println(number + "不是一个质数");
}
算法优化:
// 判断100000是不是质数
// 2 ~ 99999
//循环的次数:将近10万次,增加了时间开销
//推荐一个简化的思路
//81
//1 * 81
//3 * 27
//9 * 9
//以81的平方根9,为中心
//而且假设 a * b = 81
//那么a和b中,其中有一个必定是小于等于9的。
//另一个是大于等于9的。
//假设,都是大于9 --- 9.1 * 9.1 > 81
//假设,都是小于9 --- 8.9 * 8.9 < 81
//其中一个数字一定是小于等于平方根
//另外一个数字一定是大于等于平方根
int number = 100;
//如果这个范围之内,所有的数字都不能被number整除
//那么number就一定是一个质数。
//表示最初就认为number是一个质数
boolean flag = true;
for (int i = 2; i < Math.sqrt(number); i++) {
//范围区间[2,number的平方根]
//i 依次表示这个范围之内的每一个数字
//看number是否能被i整除就可以了
if(number % i == 0) {
// 9 % 2 = 1
flag = false;
//System.out.println(number + "不是一个质数");
break;
}/*else{
System.out.println(number + "是一个质数");
}*/
}
//只有当这个循环结束了,表示这个范围之内所有的数字都判断完毕了
//此时才能断定number是一个质数
if(flag){
System.out.println(number + "是一个质数");
}else{
System.out.println(number + "不是一个质数");
}
5.7 训练四: 猜数字小游戏
需求:
程序自动生成一个1-100之间的随机数,在代码中使用键盘录入去猜出这个数字是多少?
要求:
使用循环猜,一直猜中为止。
思路分析:
- 生成一个1-100之间的随机数
- 使用键盘录入去猜出这个数字是多少
- 把反复猜的代码写在循环中
代码示例:
//1.生成一个1-100之间的随机数
Random r = new Random();
int number = r.nextInt(100) + 1; //[1,100) --> [1,100]
System.out.println(number);
//2.使用键盘录入去猜出这个数字是多少?
Scanner sc = new Scanner(System.in);
while(true){
System.out.println("请输入一个整数");
int guessNumber = sc.nextInt();
//3.比较
if(guessNumber > number){
System.out.println("您猜的数字大了");
}else if(guessNumber < number){
System.out.println("您猜的数字小了");
}else{
System.out.println("恭喜你,猜中了");
break;
}
}
保底机制:
为了让玩家不会那么的伤心难过,特地研发出保底机制。
//需求:程序自动生成一个1-100之间的随机数字,使用程序实现猜出这个数字是多少?
//扩展小需求:加一个保底机制,3次猜不中,直接提示猜中了。
//注意点:
//1.生成随机数的代码int number = r.nextInt(100) + 1;
//不能写在循环的里面的,否则每一次都会产生一个新的随机数
//2.抽奖机制
//用点券去抽水晶
//保底 360次
//计数器
//用来统计当前已经猜了多少次。
int count = 0;
//分析
// 1. 生成一个1-100之间的随机数字
Random r = new Random();
int number = r.nextInt(100) + 1;
System.out.println(number);
// 2. 猜这个数字是多少
Scanner sc = new Scanner(System.in);
while(true){
System.out.println("请输入你要猜的数字");
int guessNumber = sc.nextInt();
//3 . 判断两个数字给出不同的提示
//猜的数字大了,提示 大了
//猜的数字小了,提示 小了
//猜的数字一样,提示猜中了
count++; //猜一次我就加一次记录。
if(count == 3){
//如果三次都没有猜对的话,那么第三次我就算你对,你也不容易!!!
System.out.println("猜中了");
break;
}
if(guessNumber > number){
System.out.println("大了");
}else if(guessNumber < number){
System.out.println("小了");
}else{
System.out.println("猜中了");
break;
}
}