for 循环语句
-
循环结构 ：
- 特征 : 重复做某件事情，具有明确的开始和停止标志
- 循环结构组成部分 :
- 初始化语句 ：用于表示循环开启时的起始状态，简单说就是循环开始时的样子
- 条件判断语句 ：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去
- 循环体语句 ：用于表示循环反复执行的内容，简单说就是循环反复执行的事情
- 条件控制语句 ：由于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去
- 循环结构对应的语法 ：
- 初始化语句 ：这里可以是一条或者多条语句，这些语句可以完成一些初始化操作
- 条件判断语句 ：这里使用一个结果值为 boolean 类型的表达式，这个表达式决定了是否执行循环体，例如 ：a < 3
- 循环体语句 ：这里可以是任意语句，这些语句将反复执行
- 条件控制语句 ：这里通常是使用一条语句来改变变量的值，从而达到控制循环是否继续向下执行的效果， i ++ , i - -
-
for 循环语句格式
格式 : for(初始化语句;条件判断语句;条件控制语句){ 循环体语句; } 执行流程 : 1.执行初始化语句 2.执行条件判断语句，看其结果是 true 还是 false 如果是 true ，继续执行 如果是 false , 循环结束 3.执行循环体语句 4.执行条件控制语句 5.回到 2 继续 -
代码测试 ：
public class Demo_1 {
public static void main(String[] args) {
/**
* 需求 ：在控制台输出五次 HelloWorld
**/
// 1. 最简单方式进行输出
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("==========================");
// 2. 使用 for循环 进行输出
for (int i = 1; i <= 5; i++) {
// 先执行初始化语句，在执行条件判断语句，接着执行语句体，最后执行条件控制语句
System.out.println(i);
System.out.println("HelloWorld");
}
}
}
- 案例 ：输出数据
public class Demo_1 {
public static void main(String[] args) {
/**
* 需求 ：在控制台输出 1-5 和 5-1 的数据
**/
// 1. 在控制台输出 1-5
for (int i = 1; i <= 5; i++) {
System.out.println(i);
}
System.out.println("===================");
// 2. 在控制台输出 5-1
for (int i = 5; i >= 1; i--) {
System.out.println(i);
}
}
}
- 案例 ：求和
public class Demo_1 {
public static void main(String[] args) {
/**
* 需求 ：求 1-5 之间的数据和，并把求和的结果在控制台输出
**/
// 1. 定义一个 int 类型的变量用于保存求和的结果，初始值为 0
int sum = 0;
// 2. 使用 for循环，依次计算 1-5 求和的结果
for (int i = 1; i <= 5; i++) {
// 3. 使用 += 表达式进行累加
sum += i;
System.out.println(sum);
}
System.out.println("======================");
System.out.println(sum);
}
}
- 案例 ：求偶数和
public class Demo_1 {
public static void main(String[] args) {
/**
* 需求 ：求 1-100 之间的偶数和，并把求和结果在控制台输出
**/
// 1. 定义一个 int 类型的变量，用于保存求和的结果,初始值为 0
int sum = 0;
// 2. 使用 for循环，依次输出 1-100 的数据
for (int i = 1; i <= 100; i++) {
// 3. 判断需要累加的值能否被 2 整除，整出后为偶数
if (i % 2 == 0) {
// 4. 使用 += 把符合的值累加到变量 sum
sum += i;
}
}
// 5. 将累加的值进行输出
System.out.println("1-100之间的偶数和为: " + sum);
}
}
- 案例 ：水仙花
public class Demo_1 {
public static void main(String[] args) {
/**
* 需求：输出所有的水仙花数 水仙花数举例:
* 371 (3*3*3) + (7*7*7) + (1*1*1) = 27 + 343 + 1 = 371
**/
// 1.定义变量，用来统计水仙花数
int temporary = 0;
// 2.水仙花数是一个三位数，在 100-999 之间
for (int i = 100; i < 1000; i++) {
// 3.定义变量，依次取出个位,十位,百位,所对应的数字
int unit = i % 10;
int tens = (i / 10) % 10;
int hundreds = ((i / 10) / 10) % 10;
// 4.对传递的值进行判断，是否符合水仙花数标准并输出
if (i == (unit*unit*unit) + (tens*tens*tens) + (hundreds*hundreds*hundreds)) {
temporary++;
System.out.println("第" + temporary + "个水仙花数为: " + i);
}
}
}
}
while 循环语句
-
while 循环语句格式
基本格式 : while(条件判断语句){ 循环体语句; } 完整格式 : 初始化语句; while(条件判断语句){ 循环体语句; 条件控制语句; } 执行流程 : 1. 执行初始化语句 2. 执行条件判断语句，看其结果是 true 还是 false ，如果是 true 继续执行 ， 如果是 false 循环结束 3. 执行循环体语句 4. 执行条件控制语句 5. 回到 2 继续执行 -
代码测试 ：
public class Test {
public static void main(String[] args) {
/**
* 在控制台输出五次 HelloWorld
**/
// 1.while 循环实现
int i = 1;
while (i <= 5) {
System.out.println("HelloWorld");
i++;
}
}
}
- 案例 ：珠穆朗玛峰
public class Test {
public static void main(String[] args) {
/**
* 需求:世界最高山峰是珠穆朗玛峰(8844.43米 = 8844430毫米),假如我们有一张足够大的纸，它的厚度是 0.1 毫米
* 请问,需要折叠多少次，可以折成珠穆朗玛峰的高度
**/
// 1.定义变量并换算单位
int peak = 8844430 * 10;
int paper = (int) (0.1 * 10);
// 2.定义一个计数器，初始值为 0
int count = 0;
// 3.while 循环实现
while (paper <= peak) {
paper *= 2;
count++;
}
// 4.输出需要折叠的次数
System.out.println("需要折叠的次数为: "+count);
}
}
do … while 循环语句
-
do … while 循环语句格式
基本格式 : do{ 循环体语句; }while(条件判断语句); 完整格式: 初始化语句; do{ 循环体语句; 条件控制语句; }while(条件判断语句); 执行流程: 1. 执行初始化语句 2. 执行循环体语句 3. 执行条件控制语句 4. 执行条件判断语句，看其结果是 true 还是 false , 如果是 true 继续执行 ， 如果是 false 循环结束 5. 回到 2 继续 -
代码测试 ：
public class Test {
public static void main(String[] args) {
/**
* 在控制台输出五次 Hello World
**/
// 1.定义初始化语句
int i = 1;
// 2.do...while 循环语句实现
do {
System.out.println("Hello World");
i++;
} while (i <= 5);
}
}
三种循环的区别
- do…while 循环最少执行一次循环体语句,其他循环语句条件为 false 则不执行循环体语句
- for 循环中的变量随着 for 循环开始而开始结束而结束，while 和 do…while 循环中的变量是在循环开始前定义好的没有局限性
- while 循环是最常用的死循环
public class Test {
public static void main(String[] args) {
/**
* 三种循环的区别
**/
// 1.do...while 循环最少执行一次循环体语句,其他循环语句条件为 false 则不执行循环体语句
for (int i = 3; i < 3; i++) {
System.out.println("for 循环");
}
int j = 3;
while (j < 3) {
System.out.println("while 循环");
j++;
}
int k = 3;
do {
System.out.println("do...while 循环");
k++;
} while (k < 3);
// 2.for 循环中的变量随着 for 循环开始而开始结束而结束,
// while 和 do...while 循环中的变量是在循环开始前定义好的没有局限性
// System.out.println(i);
System.out.println(j);
// 3.死循环
for (;;) {
System.out.println("for");
}
// 最常用的死循环
while (true) {
System.out.println("while");
}
do {
System.out.println("do...while");
} while (true);
}
}
跳转控制语句
- 跳转控制语句概述 ：
- continue 用在循环中，基于条件控制，跳过某次循环体内容的执行，继续下一次执行
- break 用在循环中，基于条件控制，终止循环体内容的执行，也就是说结束当前的整个循环
- 代码测试 ：
public class Test {
public static void main(String[] args) {
/**
* 测试跳转控制语句 continue 和 break
**/
// 1.continue 代码测试
for (int i = 1; i <= 5; i++) {
if (i % 2 == 0) {
continue;
}
System.out.println(i);
}
System.out.println("=========================");
// 2.break 代码测试
for (int i = 1; i <= 5; i++) {
if (i % 2 == 0) {
break;
}
System.out.println(i);
}
}
}
循环嵌套
- 循环嵌套概叙 ：
- 任何语句对外都可以看成是一句话，一句代码
- 分支语句中包含分支语句称为分支嵌套
- 循环语句中包含循环语句称为循环嵌套
- 代码测试 ：
public class Test {
public static void main(String[] args) {
/**
* 使用循环嵌套在控制台输出一天的小时和分钟
**/
// 1.使用 for 循环输出
for (int minute = 0; minute < 4; minute++) {
System.out.println("0时" + minute + "分");
}
System.out.println("================================");
for (int minute = 0; minute < 4; minute++) {
System.out.println("1时" + minute + "分");
}
System.out.println("================================");
for (int minute = 0; minute < 4; minute++) {
System.out.println("2时" + minute + "分");
}
System.out.println("================================");
for (int minute = 0; minute < 4; minute++) {
System.out.println("3时" + minute + "分");
}
System.out.println("================================");
// 2.使用 for 循环嵌套输出
for (int hour = 0; hour < 4; hour++) {
for (int minute = 0; minute < 4; minute++) {
System.out.println(hour + "时" + minute + "分");
}
System.out.println("================================");
}
}
}
Random
- Random 的作用和使用步骤
- 作用 ：用于产生一个随机数
- 使用步骤 ：导包，创建对象，获取随机数
- 代码测试 ：
// 1.导包
import java.util.Random;
public class Test {
public static void main(String[] args) {
/**
* Random 代码测试
**/
// 2.创建对象
Random random = new Random();
// 3.获取随机数
int number = random.nextInt(10);
// 4.输出随机数
System.out.println("random: " + number);
// 5.案例: 输出一个 1-100 的随机数
int number_1 = random.nextInt(100) + 1;
System.out.println("random: " + number_1);
}
}
- 案例 ：猜数字
// 1.导包
import java.util.Random;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
/**
* 需求: 程序自动生成一个 1-100 之间的数字，使用程序实现猜出这个数字是多少？
*
* 如果猜的数字比真实数字大，则提示你猜的数字大了
* 如果猜的数字比真实数字小，则提示你猜的数字笑了
* 如果猜的数字跟真实数据相等，则提示恭喜你猜中了
**/
// 2.创建对象
Random random = new Random();
Scanner scanner = new Scanner(System.in);
// 3.获取随机数
int number = random.nextInt(100) + 1;
// 4.定义一个 int 类型的变量接收控制台输出
int number_1 = 0;
// 5.使用 while 循环判断输入值是否等于随机数,如果相等则终止循环,不等则继续循环
while (number != number_1) {
// 6.提示并获取在控制台输入
System.out.println("请输入你所猜的数字: 1-100 之间:");
number_1 = scanner.nextInt();
// 7.判断输入的数字是否大于等于还是小于随机数,并给出不同的反馈
if (number_1 > number) {
System.out.println("你输入的数字大于随机数");
} else if (number_1 < number) {
System.out.println("你输入的数字小于随机数");
} else {
System.out.println("恭喜你猜中了");
}
}
}
}
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
