此资料是根据黑马程序员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 后大括号就不会报错

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-S0JyN9m4-1669534346108)(img/5.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mSBBQUvy-1669534346110)(img/6.png)]

2.2 if语句格式2 （如果…否则）

格式：
if (关系表达式) {
    
    
    语句体1;	
} else {
    
    
    语句体2;	
}

执行流程：

①首先计算关系表达式的值

②如果关系表达式的值为true就执行语句体

③如果关系表达式的值为false就不执行语句体

④继续执行后面的语句内容

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JJVhZLQ1-1669534346111)(img/7.png)]

示例：

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("结束");
	}
}

结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HAkG4KY6-1669534346112)(img/8.png)]

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;
        }

结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NsUZgFR9-1669534346123)(img/11.png)]

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;
            }
        }

day04——判断和循环

1. 流程控制语句

1.1 流程控制语句分类

1.2 顺序结构

2. if语句（判断）

2.1 if语句格式1 （如果）

2.1.1 练习1：老丈人选女婿

2.1.2 练习2：考试奖励

2.1.3 第一种格式的细节

2.2 if语句格式2 （如果…否则）

2.2.1 练习1：吃饭

2.2.2 练习2：影院选座

2.3 if语句格式3 （如果……如果…否则）

2.3.1 练习1：考试奖励

2.3.2 练习2：商品的价格

2.3.3 练习3：自动驾驶加强版

3. switch语句 （多重选择）

3.1 格式

3.2 执行流程

3.3 注意事项

3.4 switch的扩展知识

3.4.1 default的位置和省略情况

3.4.2 case穿透

3.4.3 switch在JDK12的新特性

3.4.4 switch和if第三种格式各自的使用场景

3.5 练习：运动计划

3.6 练习：休息日和工作日

3.7 练习：按键服务

4. 循环结构

4.1 for循环结构（掌握）

4.1.1 for循环格式

4.1.1.1 格式解释

4.1.1.2 执行流程

4.1.1.3 for循环书写技巧

4.1.2 for循环练习

4.1.2.1 输出数据

4.1.2.2 求和

4.1.2.3 求偶数和

4.1.2.4 统计次数

4.2 while循环

4.2.1 格式

4.2.2 练习

4.2.2.1 练习1：打印5次HelloWorld

4.2.2.2 练习2：珠穆朗玛峰

4.2.2.3 练习3：判断回文数

4.2.2.4 练习四：求商和余数

4.3 do…while循环

4.4 三种格式的区别

5. 高级循环

5.1 无限循环（死循环）

5.1.1 for格式

5.1.2 while格式

5.1.3 do…while格式

5.1.4 无限循环的注意事项

5.2 条件控制语句

5.2.1 break

5.2.2 continue

5.3 Random随机数

5.4 训练一：逢七过

5.5 训练二：平方根

5.6 训练三：判断是否为质数

5.7 训练四： 猜数字小游戏

猜你喜欢

3. switch语句（多重选择）

5.7 训练四：猜数字小游戏