java基础2（运算符、选择机构、循环结构、循环跳转、循环嵌套、随机数）

最新推荐文章于 2022-10-20 23:42:23 发布

帅气的浩浩

最新推荐文章于 2022-10-20 23:42:23 发布

阅读量516

点赞数 1

本文链接：https://blog.csdn.net/weixin_43693472/article/details/106551297

版权

java基础2（运算符、选择机构、循环结构、循环跳转、循环嵌套、随机数）

1运算符

1.1 算术运算符

1.1.1 算术运算符加减乘除

1.运算符：对常量或者变量进行操作/运算的符号
2.表达式：用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。
3.数学运算符:
(1)+: 加法运算
(2)-: 减法运算
(3)*: 乘法运算
(4)**/: 除法运算：**数学中的除法运算: 被除数 ÷ 除数 = 商(/: 取的是商) … 余数

1.1.2 算术运算符%

%运算符: 取余数运算符
数学中的除法运算: 被除数 ÷ 除数 = 商(/: 取的是商) … 余数(%: 取的是余数)

作用:
1.判断数字的奇偶性
偶数: 可以被2整除余数是0
奇数: 不可以被2整除余数是1

2.判断一个数字能否被另一个数字整除

1.1.3 算术运算符+的特殊用法

算术运算符+的特殊用法：
1.进行数学中的加法运算
2.+的前后有字符串,此时+不再代表数学中的加法运算,代表字符串的连接

public class Demo13Operator {
	public static void main(String[] args){
		System.out.println(5+5);//10
	
		System.out.println('A'+5);//'A'+5 ==> 65 + 5 ==> 70
		
		System.out.println('A'+'B');//'A'+'B' ==> 65 + 66 ==> 131
		
		System.out.println("HelloWorld");
		
		System.out.println("Hello"+"World");//此处+代表字符串的连接: 把World连接到Hello的后面
		/*
			表达式"5+5="+5+5: 是从左向右运算
			先计算"5+5="+5: 因为+的前面是字符串,此处+代表字符串的连接: "5+5=5"
			再计算"5+5=5"+5:因为+的前面是字符串,此处+代表字符串的连接: "5+5=55"
		*/
		System.out.println("5+5="+5+5);//5+5=55
		System.out.println("5+5="+(5+5));//5+5=10
	}
}

1.2 赋值运算符

1.2.1 赋值运算符类型

= 	赋值 		a=10，将10赋值给变量a 
+= 	加后赋值   a+=b，将a+b的值给a 	a = a + b
-= 	减后赋值   a-=b，将a-b的值给a 	a = a - b
*= 	乘后赋值   a*=b，将a×b的值给a 	a = a * b
/= 	除后赋值   a/=b，将a÷b的商给a    a = a / b
%= 	取余后赋值  a%=b，将a÷b的余数给a  a = a % b

1.2.2 赋值运算符特点

赋值运算符的特点
1.+=,-=,*=,/=,%= 如果计算结果的数据类型和左侧变量的数据类型不一致,会自动进行隐藏的强制类型转换
2.整数常量只要不超出所赋值的变量的取值范围,就可以直接赋值,内部隐藏强制类型转换

public class Demo15Operator {
	public static void main(String[] args){
		short s = 1;
		//+=,-=,*=,/=,%= 如果计算结果的数据类型和左侧变量的数据类型不一致,会自动进行隐藏的强制类型转换
		s += 1;//等价于s = (short)(s+1);
		
		System.out.println(s);
		//整数常量只要不超出所赋值的变量的取值范围,就可以直接赋值,内部隐藏强制类型转换
		byte b = 100;//内部: byte b = (byte)100;
		System.out.println(b);
	}
}

1.2.3 自增自减运算符

自增(++)和自减(–)运算符
1.作用: 就是让变量的值增加1(++)或者减少1(–)
2.使用格式:
(1)可以写在变量的前面: ++a,–a
(2)可以写在变量的后面: a++,a–

以下以++为例
3.使用方式:
(1)单独使用: 不和其它操作(赋值/打印)一起进行运算
++写在变量的前面和++写在变量的后面: 效果是一样的,都是让变量的值增加1

(2)混合使用: 和其它操作(赋值/打印)一起进行运算
++写在变量的前面和++写在变量的后面: 有重大区别
++写在变量的前面: 先++后使用先把变量的值增加1,然后再使用变量增加1之后的结果数据
++写在变量的后面: 先使用后++ 先使用变量中的值(此时还没有增加1),然后把变量的值增加1

1.3 关系运算符

1.作用:用来比较两个数据之间的大小关系

2.特点:
不管关系表达式多么简单或者多么复杂,最终的结果只有两个,要么是true,要么是false

3.分类:
== 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<b，判断a是否小于b，成立为true，不成立为false
<= a<=b，判断a是否小于或者等于b，成立为true，不成立为false

4.注意:
(1)=: 表示的是赋值 赋值运算符
(2)==: 表示的是判断是否相同 关系运算符

1.4 逻辑运算符

1.4.1 逻辑运算符的概念

1.作用:
用来连接布尔表达式的,最终的结果一定要么是true,要么是false

2.分类:
(1)&: 逻辑与,并且的意思,只有所有条件都成立(true),最终的结果才成立(true)
特点: 有false,则false
只要有一个条件是false，最终就是false
只有所有条件是true，最终才是true
(2)|: 逻辑或,或者的意思，只要有一个条件成立(true),最终的结果就是成立的(true)
特点: 有true,则true
只要有一个条件是true，最终就是true
只有所有条件是false，最终才是false
(3)^：逻辑异或，相同为false，不同为true ----基本不用,了解即可
(4)!: 逻辑取反
!true 就是 false，!false 就是true

1.4.2 逻辑运算符的短路效果

短路的逻辑运算符
1.基本使用
(1)短路逻辑与&&: 左侧为false,右侧不计算
(2)短路逻辑与||: 左侧为true,右侧不计算

2.特点:
	(1)&&和&最终的结果是一样的,但是&&具有短路效果可以提高效率
    (2)||和|最终的结果是一样的,但是||具有短路效果可以提高效率

1.5 三元运算符

1.格式:
数据类型变量名称 = 布尔表达式1 ? 表达式2 : 表达式3;
注意:
布尔表达式1: 这个式子不管多么复杂,也不管多么简单,结果必须是布尔(boolean)类型(true/false)
2.执行流程:
(1)计算布尔表达式1的结果,看是true还是false
(2)如果布尔表达式1的结果是true,就把表达式2的最终结果赋值给左侧的变量
(3)如果布尔表达式1的结果是false,就把表达式3的最终结果赋值给左侧的变量

需求：
    一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm，身高需要使用键盘录入
    请用程序实现获取这三个和尚的最高身高。
    
实现步骤:
	1.创建键盘录入Scanner类的对象(先导包,后创建对象)
		自动导包1: 直接写字母Sc,会出现提示,选择Scanner,回车       ------------建议-----------
        自动导包2: 直接写单词Scanner,alt + 回车,选择需要的Scanner,回车

    2.获取键盘录入的3个整数数字(代表三个和尚的身高),分别保存到3个int变量h1,h2,h3中
    3.使用三元运算符计算h1和h2的最大值,保存到int变量temp中
    4.再使用三元运算符计算temp和h3的最大值,保存到int变量max中
    5.打印max的值

public class Demo02ScannerHeShang {
    public static void main(String[] args) {
        //1.创建键盘录入Scanner类的对象(先导包,后创建对象)
        Scanner sc = new Scanner(System.in);

        //2.获取键盘录入的3个整数数字(代表三个和尚的身高),分别保存到3个int变量h1,h2,h3中
        System.out.println("请输入第一个和尚的身高(整数数字): ");
        int h1 = sc.nextInt();

        System.out.println("请输入第二个和尚的身高(整数数字): ");
        int h2 = sc.nextInt();

        System.out.println("请输入第三个和尚的身高(整数数字): ");
        int h3 = sc.nextInt();

        System.out.println("您输入的三个和尚的身高: "+h1+", "+h2+", "+h3);

        //3.使用三元运算符计算h1和h2的最大值,保存到int变量temp中
        int temp = (h1 > h2) ? h1 : h2;

        //4.再使用三元运算符计算temp和h3的最大值,保存到int变量max中
        int max = (temp > h3) ? temp : h3;

        //5.打印max的值
        System.out.println("以上三个和尚的最大身高: "+max);
    }
}

1.6 运算符优先级

在这里插入图片描述

2 流程控制

2.1 流程控制概念

流程：简单来讲所谓流程就是完成一件事情的多个步骤组合起来就叫做一个流程
注意: 在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。
举例：
现在你正在学习Java基础课程
流程: 学习Java的想法 --> 网站和咨询老师沟通 --> 安排课程 --> 听课

流程控制语句分类
1.顺序结构: 按照代码的书写顺序从上到下依次执行
2.选择结构:
(1)if语句【重点的重点】
(2)switch语句【重点】
3.循环结构：
(1)for循环【重点的重点】
(2)while循环【重点】
(3)do-while循环【了解】

2.2 顺序结果

public class DemoSequence {
    public static void main(String[] args) {
        System.out.println("开始....");
        System.out.println("今天天气不错,挺风和日丽的....1");
        System.out.println("我们上午黑马java直播课....2");
        System.out.println("这的确挺爽的....3");
        System.out.println("结束....");
    }
}

3 选择结构

3.1 选择机构if

3.1.1 if语句的第一种格式介绍

1.if语句的第一种格式:
if(布尔表达式) {
语句体;
}
其它语句;

2.执行流程:
(1)计算if语句()中布尔表达式的结果,看是true,还是false
(2)如果if语句()中布尔表达式的结果是true,执行if语句()后{}中的语句体,紧接着执行其它语句
(3)如果if语句()中布尔表达式的结果是false,不执行if语句()后{}中的语句体,直接执行其它语句

3.注意:
(1)if语句的第一种格式,适用于有一种情况的场景
(2)if后面()中的表达式,不管多么复杂,也不管多么简单,结果必须是布尔类型
(3)if后面{}中的语句体,要么被执行,要么被跳过
(4)if后面{}中的语句体: 一条或者多条语句
(5)if语句后面()和{}之间没有分号
(6)if语句后面的{}中如果只有一条语句,那么{}可以省略,但是建议初学者保留

在这里插入图片描述

练习
	需求1：判断a和b的值是否相等，如果相等，就在控制台输出：a等于b
	需求2：判断a和c的值是否相等，如果相等，就在控制台输出：a等于c
public class Demo01If {
    public static void main(String[] args) {
        System.out.println("开始....");
        //定义2个int变量a和b,并初始化
        int a = 10;
        int b = 20；
        //使用if语句第一种格式判断a和b的值是否相同
        if(a == b) {
            System.out.println(a+"等于"+b);
        }
        //定义1个int变量c,并初始化
        int c = 10;

        //使用if语句第一种格式判断a和c的值是否相同
        if(a == c) {
            System.out.println(a+"等于"+c);
        }
    }
}

3.1.2 if语句的第二种格式介绍

1.if语句的第二种格式:
if(布尔表达式) {
语句体1;
} else {
语句体2;
}
其它语句;

2.执行流程:
(1)计算if语句()中布尔表达式的结果,看是true,还是false
(2)如果if语句()中布尔表达式的结果是true,执行if后面{}中的语句体1,接着执行其它语句
(3)如果if语句()中布尔表达式的结果是false,执行else后面{}中的语句体2,接着执行其它语句

3.注意:
(1)if语句的第二种格式,适用于有两种情况的场景
(2)if后面()中的表达式,不管多么复杂,也不管多么简单,结果必须是布尔类型
(3)语句体1和语句体2,只能有一个被执行,是一个二选一的情况,是一个是与否的情况
(4)if和else后面{}中的语句体: 一条或者多条语句
(5)if语句后面()和{}之间没有分号,而且else 和 {}之间也没有分号
(6)if语句后面的{}中如果只有一条语句,那么{}可以省略,但是建议初学者保留

在这里插入图片描述

需求：
    判断a是否大于b，如果是，在控制台输出：a的值大于b，否则，在控制台输出：a的值不大于b
    
实现步骤:
	1.定义2个int变量a和b,并初始化
	2.因为有两种输出结果,所以使用if语句第二种格式对a和b的大小进行判断,并输出不同的结果
public class Demo02IfElse {
    public static void main(String[] args) {
        System.out.println("开始....");

        //1.定义2个int变量a和b,并初始化
        int a = 30, b = 20;
        
        //2.因为有两种输出结果,所以使用if语句第二种格式对a和b的大小进行判断,并输出不同的结果
        //30>20:true
        if(a > b) {
            System.out.println(a+"的值大于"+b);
        } else {
            System.out.println(a+"的值不大于"+b);
        }

        System.out.println("结束....");//模拟其它语句
    }
}

3.1.3 if语句的第三种格式介绍

1.if语句的第三种格式:
if(布尔表达式1) {
语句体1;
} else if(布尔表达式2) {
语句体2;
}
…
else if(布尔表达式n) {
语句体n;
} else {
语句体n+1;
}
其它语句;

2.执行流程:
(1)首先计算布尔表达式1的值
(2)如果值为true就执行语句体1；如果值为false就计算布尔表达式2的值
(3)如果值为true就执行语句体2；如果值为false就计算布尔表达式3的值
(4)…
(5)如果没有任何布尔表达式为true，就执行语句体n+1。

3.注意:
(1)if语句的第三种格式,适用于有多种情况(至少两种以上)的场景
(2)if后面()中的表达式,不管多么复杂,也不管多么简单,结果必须是布尔类型
(3)语句体1到语句体n+1,只能有一个被执行,是一个多选一的情况
(4)if和else后面{}中的语句体: 一条或者多条语句
(5)if语句后面()和{}之间没有分号,而且else 和 {}之间也没有分号
(6)if语句后面的{}中如果只有一条语句,那么{}可以省略,但是建议初学者保留
(7)只能在if后面写条件,没有if就不能写条件,不能直接在else后面写(条件)
(8)最后一个else后面没有if,是用来兜底的
如果上面的所有的if都不成立,就执行最后一个else中{}中的代码

在这里插入图片描述

需求:
	键盘录入一个星期数(1,2,...7)，输出对应的星期一，星期二，...星期日
演示效果:
	输入 1 输出 星期一
    输入 2 输出 星期二
    输入 3 输出 星期三 
    输入 4 输出 星期四 
    输入 5 输出 星期五 
    输入 6 输出 星期六 
    输入 7 输出 星期日 
    输入 其它数字 输出 数字有误
        
实现步骤:
	1.创建键盘录入Scanner类的对象(1.导包 2.创建)
    2.获取键盘录入的1-7之间的一个整数数字(代表星期数),保存到一个int变量week中
    3.因为week中的数字有7+1中情况,所以使用if语句第三种格式对week中的数据进行判断,并输出不同的结果

public class Demo01IfElseIfElseWeek {
    public static void main(String[] args) {
        //1.创建键盘录入Scanner类的对象(1.导包 2.创建)
        Scanner sc = new Scanner(System.in);

        //2.获取键盘录入的1-7之间的一个整数数字(代表星期数),保存到一个int变量week中
        System.out.println("请输入一个1到7之间的整数数字(代表星期数): ");
        int week = sc.nextInt();

        //3.因为week中的数字有7+1中情况,所以使用if语句第三种格式对week中的数据进行判断,并输出不同的结果
        if(week == 1) {
            System.out.println("星期一");
        } else if(week == 2) {
            System.out.println("星期二");
        } else if(week == 3) {
            System.out.println("星期三");
        } else if(week == 4) {
            System.out.println("星期四");
        } else if(week == 5) {
            System.out.println("星期五");
        } else if(week == 6) {
            System.out.println("星期六");
        } else if(week == 7) {
            System.out.println("星期日");
        } else /*if(week<1 || week>7)*/ {//隐藏条件: week<1 || week >7
            System.out.println("您输入的代表星期数的数字: "+week
                    +" 是不存在的,哥屋恩...");
        }
        System.out.println("结束....");
    }
}

3.2 选择结果 switch

3.2.1 switch语句格式和介绍

1.switch语句的格式:
switch(表达式) {
case 常量值1:
语句体1;
break;
case 常量值2:
语句体2;
breeak;
…
case 常量值n:
语句体n;
break;
default:
语句体n+1;
break;
}
其它语句;

2.执行流程:
(1)首先计算出表达式的值
(2)其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
(3)最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

3.注意事项:
(1)switch后面()中表达式的数据类型,只能是以下几种类型:
byte/short/char/int String/枚举
(2)break: 作用是用来结束switch的,只要执行break,直接从switch语句中跳出来,
执行switch语句后续的其它代码
(3)case后面只能写常量,而且不能重复
(4)如果所有的case和default后面的都有break,那么case和default的书写顺序无所谓
(5)default也是用来兜底的,如果所有case中常量值和表达式的值都不相同,直接执行default中的代码
(6)如果default写在了最后,则可以省略default中的break

在这里插入图片描述

public class Demo01Switch {
    public static void main(String[] args) {
        int num = 2;
        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;
        }
        System.out.println("结束....");
    }
}

3.2.2 使用case穿透优化根据月份输出对应的季节的案例

案例：需求：
一年有12个月，分属于春夏秋冬4个季节，
键盘录入一个月份，请用程序实现判断该月份属于哪个季节，并输出。

不使用case穿透：

public class Demo02SwitchMonth {
    public static void main(String[] args) {
        //1.创建键盘录入Scanner类的对象(1.导包 2.创建)
        Scanner sc = new Scanner(System.in);

        //2.获取键盘录入的1-12之间的一个整数数字(代表月份),保存到int变量month中
        System.out.println("请输入一个1-12的整数数字(代表月份): ");
        int month = sc.nextInt();

        //3.因为month中的数据有12+1种情况,所以使用switch判断month中的值,根据不同的值输出不同的结果
        switch (month) {
            case 1:
                System.out.println("冬季");
                break;
            case 2:
                System.out.println("冬季");
                break;
            case 12:
                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;
        }
        System.out.println("结束....");
    }
}

使用case穿透：

发现问题:
前面Demo02SwitchMonth.java文件中出现了大量的重复的代码
1,2,12代码重复,3,4,5代码重复,6,7,8代码重复,9,10,11代码重复
每三个case中的代码都是相同的

解决方案使用case穿透:
如果多个连续的case中具有相同的代码和break,可以只保留最后一个case的代码和break,前面的多个case中的代码和break省略不写。
在switch语句中，如果case的后面不写break，将出现穿透现象，也就是不会在判断下一个case的值，直接向后运行，直到遇到break，或者整体switch结束。

public class Demo03SwitchMonthBetter {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个1-12的整数数字(代表月份): ");
        int month = sc.nextInt();
        
        switch (month) {//3
            case 1:
            case 2:
            case 12:
                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;
        }
        System.out.println("结束....");
    }
}

4 循环结构

4.1 循环语句 for

4.1.1 for循环语句介绍

1.for循环格式:
for(初始化表达式1;布尔表达式2;步进表达式4){
循环体3;
}
其它语句;

2.执行流程:
1,2(循环条件:true),3,4 --> 2(循环条件:true),3,4 --> … --> 直到布尔表达式2(循环条件:false)结束for循环,执行for循环后面的其它语句。
在这里插入图片描述

4.1.2 for练习

需求:
求1-100之间的偶数和，并把求和结果在控制台输出

实现步骤:
1.定义int变量sum,初始值0,用来累加求和
2.使用for循环,获取1-100的数字,保存到循环变量num中
2.1判断如果循环变量num中的数字是偶数: num%2==0
2.2把当前循环变量中的偶数数字,累加到求和变量sum中
3.for循环结束打印sum的值

public class Demo04ForSumOu {
    public static void main(String[] args) {
        //1.定义int变量sum,初始值0,用来累加求和
        int sum = 0;

        //2.使用for循环,获取1-100的数字,保存到循环变量num中
        for (int num = 1; num <= 100; num++) {
            //2.1判断如果循环变量num中的数字是偶数: num%2==0
            if (num % 2 == 0) {
                //2.2把当前循环变量中的偶数数字,累加到求和变量sum中
                sum += num;
            }
        }
        //3.for循环结束打印sum的值
        System.out.println("1-100的偶数数字之和: "+sum);
        System.out.println("------------------");

        //1.定义int变量sum2,初始值0,用来累加求和
        int sum2 = 0;

        //2.使用for循环,获取1-100的偶数数字,保存到循环变量num中
        for(int num =0; num<=100;/*num++,num++*//*num+=2*/num = num + 2) {
            //2.1把循环变量num中的偶数数字,累加到求和变量sum中
            sum2 += num;
            //System.out.println(num);
        }
        System.out.println("1-100的偶数数字之和: "+sum2);
    }
}

需求:
在控制台输出所有的“水仙花数”

解释：什么是水仙花数？
水仙花数，指的是一个三位数，个位、十位、百位的数字立方和等于原数
例如 153 333 + 555 + 111 = 27 + 125 + 1 = 153

实现步骤:
1.使用for循环获取所有的三位数字,保存到循环变量num中
1.1计算循环变量num中当前三位数字的个位,十位,百位,分别保存到int变量ge(个位),shi(十位),bai(百位)中
1.2计算个位,十位,百位数字的立方和,保存到int变量sum中
1.3判断如果该三位数字的立方和sum 等于该三位数字num: 说明是水仙花数字
1.4打印该水仙花数字

public class Demo02ForSXH {
    public static void main(String[] args) {
        //1.使用for循环获取所有的三位数字,保存到循环变量num中
        for (int num = 100; num <= 999; num++) {
            //System.out.println(num);
            //1.1计算循环变量num中当前三位数字的个位,十位,百位,分别保存到int变量ge(个位),shi(十位),bai(百位)中
            int ge = num%10;//个位
            int shi = num/10%10;//十位
            int bai = num/100%10;//百位

            //1.2计算个位,十位,百位数字的立方和,保存到int变量sum中
            int sum = ge*ge*ge + shi*shi*shi + bai*bai*bai;

            //1.3判断如果该三位数字的立方和sum 等于该三位数字num: 说明是水仙花数字
            if (sum == num) {
                //1.4打印该水仙花数字
                System.out.println(num);
            }
        }
    }
}

4.2 循环语句 while

4.2.1 while循环语句介绍

1.while循环格式:
初始化表达式1;
while(布尔表达式2){
循环体3;
步进表达式4;
}
其它语句;

2.执行流程:
1,2(循环条件: true),3,4 --> 2(循环条件: true),3,4 --> … --> 直到布尔表达式2(循环条件: false),结束while循环,直接执行while循环后面的其它代码

在这里插入图片描述

4.2.2 练习

求：
世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米)，假如我有一张足够大的纸，它的厚度是0.1毫米。
请问，我折叠多少次，可以折成珠穆朗玛峰的高度?
折纸(折叠后的厚度是原有厚度的2倍,而不是平方的关系):
原来: 0.1 paper
第一次: 0.12: 0.2 paper = paper * 2
第二次: 0.22: 0.4
第三次: 0.42: 0.8
第四次: 0.82: 1.6
…

实现步骤:
1.定义int变量count,初始值0,用来统计折叠纸张的次数
2.定义2个double变量zf(珠峰的高度)和paper(纸张的厚度),分别代表珠峰的高度和纸张的厚度,并根据题目需求进行初始化
3.使用while循环,完成折叠纸张达到珠峰的高度
3.1布尔表达式,循环条件: 只要折叠后的纸张高度小于珠峰的高度 paper < zf
3.2循环体: 折叠一次纸张,使得纸张的厚度变为原来的2被 paper = paper *2 或者 paper *= 2
3.3步进表达式: 计数器count的值增加1
4.while循环结束,打印count的值

public class Demo02WhileZF {
    public static void main(String[] args) {
        //1.定义int变量count,初始值0,用来统计折叠纸张的次数
        int count = 0;

        //2.定义2个double变量zf(珠峰的高度)和paper(纸张的厚度),分别代表珠峰的高度和纸张的厚度,并根据题目需求进行初始化
        double zf = 8844430,paper = 0.1;

        //3.使用while循环,完成折叠纸张达到珠峰的高度
        //3.1布尔表达式,循环条件: 只要折叠后的纸张高度 小于 珠峰的高度 	paper < zf
        while (paper < zf) {
            //3.2循环体: 折叠一次纸张,使得纸张的厚度变为原来的2被 paper = paper *2 或者 paper *= 2
            paper *= 2;//paper = paper *2

            //3.3步进表达式: 计数器count的值增加1
            count++;
            //System.out.println("折叠第"+count+"次纸张的厚度: "+paper);
        }
        //4.while循环结束,打印count的值
        System.out.println("总共折叠次数: "+count);
        //System.out.println("折叠后纸张的最终厚度: "+paper);//1.34217728E7 ==> 13421772.8 8844430
    }
}

4.3 循环语句 do-while

4.3.1 do-while循环语句介绍

1.do-while循环格式:
初始化表达式1;
do {
循环体3;
步进表达式4;
} while(布尔表达式2);
其它语句;

2.执行流程:
1,3,4 --> 2(循环条件:true),3,4 --> 2(循环条件:true),3,4 --> … --> 直到布尔表达式2(循环条件:false)的结果为false,解释do-while循环,执行do-while后面的其它语句

在这里插入图片描述

4.3.2 练习

do-while循环练习：
	在控制台输出5次HelloWorld
/*
    do-while循环练习：
	    在控制台输出5次HelloWorld
 */
public class Demo01DoWhile {
    public static void main(String[] args) {

        int i = 1;//初始化表达式1

        do {

            System.out.println("HelloWorld...."+i);//循环体3

            i++;//步进表达式4

        } while(i<=5);//布尔表达式2 i: 6 6<=5: false 结束do-while循环,执行后面的其它语句

        System.out.println("do...while...end");
    }
}

4.4 循环语句的区别

4.4.1三种循环的区别总结

1.建议使用的顺序: for,while,do-while
2.循环次数确定的话,建议使用for,循环次数不确定建议使用while
循环次数不确定需要先写成死循环的格式【while好看】
3.do-while循环来讲的话,至少执行一次
4.while和do-while循环而言,循环结束后,初始化条件中定义的变量可以继续使用,
但是for循环的不能使用(在for循环内部定义初始化语句)

/*
    while和do-while循环而言,循环结束后,初始化条件中定义的变量可以继续使用,
		但是for循环的不能使用(在for循环内部定义初始化语句,只能在for循环内部使用)

 */
public class Demo03LoopDiff {
    public static void main(String[] args) {
        //在for循环内部定义的变量,只能在for循环内部使用
        //出了for循环就不能使用了
        for (int i = 1; i <= 3; i++) {
            System.out.println("Hello...for..." + i);
        }
        //错误: i是在for循环内部定义的,只能在for循环内部使用
        //System.out.println("Hello...for...end..."+i);

        int j = 1;
        while (j <= 3) {
            System.out.println("Hello...while..." + j);
            j++;
        }
        //while循环初始化表达式中定义的变量,是在while循环外面定义的
        //while循环结束后,变量可以继续使用
        System.out.println("Hello...while...end..." + j);//4

        int k = 1;
        do {
            System.out.println("Hello...do...while..." + k);
            k++;
        } while (k <= 3);
        //do-while循环初始化表达式中定义的变量,是在do-while循环外面定义的
        //do-while循环结束后,变量可以继续使用
        System.out.println("Hello...do...while...end..." + k);//4

    }
}

4.4.2 死循环

1.概念: 永不休止的循环
2.分类:
(1)for循环的死循环格式: for芬芬
	for(;;){
		...
	}

(2)while循环的死循环格式        -------推荐使用
	while(true){
		...
	}

(3)do-while循环的死循环格式
	do {
		...
	} while(true);

5 循环跳转

5.1 break

5.1.1 break的介绍

break作用:
1.可以使用在switch语句中,结束switch语句
2.可以使用在循环中,结束循环
(1)本次循环不再执行
(2)无论剩余多少次循环,也不再执行,相当于从循环中跳出来,执行循环后面的其它代码
3.break不能使用在除了switch和循环之外的其它位置

5.1.2 break的使用

在这里插入图片描述

5.2 continue

5.2.1 continue的介绍

continue的作用:
1.只能使用在循环中,用来提前结束本次循环,继续进行下一次循环
2.不能使用在除了循环以外的其它位置

5.2.2 continue的使用

在这里插入图片描述

6 循环嵌套

6.1 循环嵌套的概念和格式

1.概念: 使用一个循环作为另外一个循环的循环体,外面的循环称为外层循环,内部的循环称为内层循环

2.格式(for嵌套):
for(外初始化表达式1;外布尔表达式2;外步进表达式7) {
for(内初始化表达式3;内布尔表达式4;内步进表达式6){
内循环体5;
}
}
其它语句;

3.执行流程:
1,2(外层循环条件:true)
3,4(内层循环条件:true),5,6 --> 4(内层循环条件:true),5,6 --> … --> 直到4(内层循环条件:false),说明内层循环结束, 执行7(外层循环的步进表达式)
2(外层循环条件:true)
3,4(内层循环条件:true),5,6 --> 4(内层循环条件:true),5,6 --> … --> 直到4(内层循环条件:false),说明内层循环结束, 执行7(外层循环的步进表达式)
…
2(外层循环条件:false),结束外层for循环,执行外层for循环后面的其它语句

6.2 练习

需求:
使用嵌套循环，打印2021年至2023年月份，格式：xxxx年x月

public class Demo02ForForMonth {
    public static void main(String[] args) {
        for (int year = 2021; year <= 2023; year++) {//外层循环: 控制年份 2021到2023年
            for (int month = 1; month <= 12; month++) {//内层循环: 控制月份,每年都有12个月 从1月到12月
                System.out.println(year+"年"+month+"月");
            }
        }
        System.out.println("main...end...");
    }
}

7 随机数

7.1 随机数Random的介绍

1.概念: java.util包中有个类Random,就是专门用来产生随机数字的

2.随机数Random类的使用步骤:
java.util.Random类和java.util.Scanner类都属于引用类型,使用步骤相同,都是3个步骤
(1)导包(找到我们要使用的类):
格式: import 包名.类名;
注意:
a.java.lang包中的类,不用导包,可以直接使用
b.当前类和要使用的类,处于同一个包中,不用导包
c.快捷键: alt + 回车
Random类的导包: import java.util.Random;

(2)创建对象
格式: 类名对象名 = new 类名(…);
类名: class关键字后面的名字叫做类名
创建键盘录入Scanner类的对象: Scanner sc = new Scanner(System.in);
注意: System.in目前是固定写法,先记住
创建产生随机数的Random类的对象: Random r = new Random();
注意: 右侧()中什么都不用写,目前是固定写法,先记住

(3)使用:
r.nextInt(): 产生一个int范围(正负21亿)内的随机数字使用不多
r.nextInt(int类型整数数字n): 产生一个0(包含)到n(不包含n)之间的随机整数数字
举例:
r.nextInt(10): 产生一个0(包含)到10(不包含10)之间的随机数字
[0,10): 从0(包含)开始到10(不包含)
等价于 [0,9]: 从0(包含)开始到9(包含)

7.2 练习

1.需求：程序自动生成一个1-100之间(包含1,包含100)的数字，使用程序实现猜出这个数字是多少？

2.效果：
如果猜的数字比真实数字大，提示你猜的数据大了
如果猜的数字比真实数字小，提示你猜的数据小了
如果猜的数字与真实数字相等，提示恭喜你猜中了

3.使用的知识点:
(1)使用Random类产生一个随机数字(1.导包 2.创建对象 3.调用nextInt(…))
(2)使用Random类获取键盘录入的用户猜测的数字(1.导包 2.创建对象 3.调用nextInt())
(3)用户多少次可以猜对,不确定,循环次数不确定,使用while(true)
(4)使用if语句的第三种格式,比较两个变量中数据值的大小关系
(5)如果猜对了,需要停止循环 break
4.实现步骤:
(1)创建产生随机数字的Random类的对象
(2)使用Random类的对象产生一个1-100之间(包含1,包含100)的数字,保存到int变量guessNum中,以供用户猜测
(3)创建键盘录入Scanner类的对象
(4)用户多少次可以猜对,次数是不确定的,循环次数不确定,使用while(true)或者for(;😉 推荐使用while(true)
//步骤(5)到(6)是一个循环过程,循环次数不确定,放入到while(true)中
(5)获取键盘录入的用户猜测的整数数字,保存到int变量inputNum中
(6)使用if语句的第三种格式,比较用户猜测的数字和产生的随机数字的大小关系
a.如果用户猜测的数字 inputNum 大于产生的随机数字 guessNum : 提示 “你猜的数据大了”
b.如果用户猜测的数字 inputNum 小于产生的随机数字 guessNum : 提示 “你猜的数据小了”
c.如果用户猜测的数字 inputNum 等于产生的随机数字 guessNum : 提示 “恭喜你猜中了”,并且结束循环

public class Demo03GuessNum {
    public static void main(String[] args) {
        //(1)创建产生随机数字的Random类的对象
        Random r = new Random();

        //(2)使用Random类的对象产生一个1-100之间(包含1,包含100)的数字,保存到int变量guessNum中,以供用户猜测
        //[1,100] --> [0,99] + 1 --> [0,100) + 1 --> r.nextInt(100) + 1
        int guessNum = r.nextInt(100) + 1;

        //(3)创建键盘录入Scanner类的对象
        Scanner sc = new Scanner(System.in);

        //(4)用户多少次可以猜对,次数是不确定的,循环次数不确定,使用while(true)或者for(;;)   推荐使用while(true)
        //步骤(5)到(6)是一个循环过程,循环次数不确定,放入到while(true)中
        while (true) {
            //(5)获取键盘录入的用户猜测的整数数字,保存到int变量inputNum中
            System.out.println("请输入您猜测的数字(1-100之间的整数):");
            int inputNum = sc.nextInt();

            //(6)使用if语句的第三种格式,比较用户猜测的数字和产生的随机数字的大小关系
            if(inputNum > guessNum) {
                //a.如果 用户猜测的数字 inputNum  大于 产生的随机数字 guessNum
                //提示 "你猜的数据大了"
                System.out.println("你猜的数据大了");
            } else if(inputNum < guessNum) {//b.如果 用户猜测的数字 inputNum  小于 产生的随机数字 guessNum
                //提示 "你猜的数据小了"
                System.out.println("你猜的数据小了");
            } else {
                //c.如果 用户猜测的数字 inputNum  等于 产生的随机数字 guessNum : 提示 "恭喜你猜中了"
                System.out.println("恭喜你猜中了");
                //并且结束循环
                break;
            }
        }

    }
}

nt guessNum = r.nextInt(100) + 1;

    //(3)创建键盘录入Scanner类的对象
    Scanner sc = new Scanner(System.in);

    //(4)用户多少次可以猜对,次数是不确定的,循环次数不确定,使用while(true)或者for(;;)   推荐使用while(true)
    //步骤(5)到(6)是一个循环过程,循环次数不确定,放入到while(true)中
    while (true) {
        //(5)获取键盘录入的用户猜测的整数数字,保存到int变量inputNum中
        System.out.println("请输入您猜测的数字(1-100之间的整数):");
        int inputNum = sc.nextInt();

        //(6)使用if语句的第三种格式,比较用户猜测的数字和产生的随机数字的大小关系
        if(inputNum > guessNum) {
            //a.如果 用户猜测的数字 inputNum  大于 产生的随机数字 guessNum
            //提示 "你猜的数据大了"
            System.out.println("你猜的数据大了");
        } else if(inputNum < guessNum) {//b.如果 用户猜测的数字 inputNum  小于 产生的随机数字 guessNum
            //提示 "你猜的数据小了"
            System.out.println("你猜的数据小了");
        } else {
            //c.如果 用户猜测的数字 inputNum  等于 产生的随机数字 guessNum : 提示 "恭喜你猜中了"
            System.out.println("恭喜你猜中了");
            //并且结束循环
            break;
        }
    }

}

}