模块四 流程控制

于 2024-03-15 09:16:25 发布
阅读量770 收藏 16
点赞数 19
分类专栏： Java 文章标签： java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45758221/article/details/136728075
版权

回顾与重点

模块三回顾

  1. idea → 自己看

  2. 运算符

    1. 算数运算符：+（加法）、 - （减法）、* （乘法）、/（除法）、 %（取余）

      +：字符串拼接 → 内容直接往后拼接

      自增自减：++ –

      a.单独使用：符号在前在后都是先运算

      b.混合使用：符号在前先运算，在使用运算后的值

      ​ 符号在后，先使用原值，在运算

    2. 赋值运算符：=（等于）、 +=（加等）、 -=（减等）、 *=（乘等）、 /=（除等）、 %=（模等）

    3. 比较运算符：：结果都是Boolean型的

      ==（等等）、 >（大于）、 <（小于）、 >= （大于或等于）、<=（小于或等于）、 !=（不等于）

    4. 逻辑运算符：连接Boolean结果的，结果还是 boolean

      &&（短路效果）、||（短路效果）、!（取反）、^（异或）

    5. 三元运算符

      a.格式

      ​ boolean 表达式?表达式1:表达式2;

      b.执行流程：先走boolean表达式，如果是true，就走"?"后面的表达式1；否则就走”：“后面的表达式2.

模块四重点

  1. 会使用 Scanner 和 Random
  2. 会使用switch以及知道case的穿透性
  3. 会使用if
  4. 会使用for循环，while循环，嵌套循环等

第一章 Scanner键盘录入

1.1 Scanner的介绍

  1. 概述：是Java定义好的一个类

  2. 作用：将数据通过键盘录入的形式放到代码中参与运行

  3. 位置：java.util

1.2 Scanner的使用

  1. 导包：通过导包的方式找到要使用的类 → 导包位置：类上

    import java.util.Scanner → 导入的是哪个包的哪个类

  2. 创建对象

    Scanner 变量名 = new Scanner(System.in);

  3. 调用方法，实现键盘录入

    变量名.nextInt()  →  输入整数int型的

变量名.next()  →  输入字符串 String型的

image-20240312050035162

1.3 Scanner练习

import java.util.Scanner;

public class Demo01Scanner {
    public static void main(String[] args) {
        // 创建对象
        Scanner sc = new Scanner(System.in);
        // 录入 int 型整数
        int data1 = sc.nextInt();
        System.out.println("data1 = " + data1);

        // 录入String型字符串
        String str = sc.next();
        System.out.println("str = " + str);
    }
}

// ==========================================
  import java.util.Scanner;

  public class Demo02Scanner {
    public static void main(String[] args) {
        // 创建对象
        Scanner sc = new Scanner(System.in);
        // 录入 int 型整数
        int old1 = sc.nextInt();
        System.out.println("old1 = " + old1);

        int old2 = sc.nextInt();
        System.out.println("old2 = " + old2);

        int old3 = sc.nextInt();
        System.out.println("old3 = " + old3);

        int temp = old1 > old2 ? old1 : old2;

        int max = temp > old3 ? temp : old3;
        System.out.println("max = " + max);
    }
}

1.4 next() 和 nextLine()的区别

变量名.next() :录入字符串 → 遇到空格和回车就结束录入了

变量名.nextLine() :录入字符串 → 遇到回车就结束录入了

import java.util.Scanner;

public class Demo03Scanner {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        String str = sc.next();
        System.out.println("str = " + str);

        String str1 = sc.nextLine();
        System.out.println("str1 = " + str1);
    }
}

Exception in thread "main" java.util.InputMismatchException
	at java.base/java.util.Scanner.throwFor(Scanner.java:939)
	at java.base/java.util.Scanner.next(Scanner.java:1594)
	at java.base/java.util.Scanner.nextInt(Scanner.java:2258)
	at java.base/java.util.Scanner.nextInt(Scanner.java:2212)
	at com.atguigu.a_scanner.Demo04Scanner.main(Demo04Scanner.java:9)

报错原因：录入的数据和要求的数据类型不一致

第二章 Random 随机数

2.1 Random 随机数的介绍

学习 Random 和学习Scanner的方式方法一样

  1. 概述

    java自带的一个类

  2. 作用

    可以在指定的范围内随机一个整数

  3. 位置

    java.util

2.2 Random 随机数的使用

  1. 导包

    import java.util.Random;

  2. 创建对象

    Random 变量名 = new Random();

  3. 调用方法，生成随机数

    变量名.nextInt() → 在int的取值范围内随机一个整数

    import java.util.Random;

public class Demo01Random {
    public static void main(String[] args) {
        // 创建对象
        Random random = new Random();
        int num = random.nextInt();
        System.out.println("num = " + num);
    }
}

  4. 在指定范围内随机一个数：

    nextInt(int bound) → 在0 — (bound - 1) 之间

    比如：

    a. nextInt(10) → 0—9

b.在1—10之间随机一个数：nextInt(10)+1 → (0—9) + 1 → 1—10

c.在1—100之间随机一个数：nextInt(100)+1 → (0—99) + 1→ 1—100

d.在100—999之间随机一个数：nextInt(900)+100 → (0—899) + 100→ 100—999

    import java.util.Random;

public class Demo02Random {
    public static void main(String[] args) {
        // 创建对象
        Random rd = new Random();
        // 在1-100之间随机
        int data1 = rd.nextInt(99) + 1;
        System.out.println("data1 = " + data1);

        System.out.println("=========================");
        // 在100-999之间随机
        int data2 = rd.nextInt(900) + 100;
        System.out.println("data2 = " + data2);
    }
}

第三章 流程控制语句

3.1 switch(选择语句)

学 switch if 循环必须要先掌握定义格式，然后掌握执行流程（带一个数进去，根据执行流程观察值的变化）

3.1.1 switch 基本使用

  1. 格式

    switch(变量) {
	case 常量值1:
		执行语句1;
		break;
	case 常量值2:
		执行语句2;
		break;
	....
	default:
		执行语句n;
		break;
}

  2. 执行流程

    用变量接收的值和下面的case后面的常量匹配，匹配上哪个case就执行哪个case对应的执行语句，如果以上所有case都没有匹配上，就走default对应的执行语句n

  3. break关键字

    代表结束switch语句

import java.util.Scanner;

public class Demo01Switch {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请您输入一个整数");
        int data = sc.nextInt();
        switch (data) {
            case 1:
                System.out.println("鹅鹅鹅");
                break;
            case 2:
                System.out.println("曲项向天歌");
                break;
            case 3:
                System.out.println("白毛浮绿水");
                break;
            case 4:
                System.out.println("红掌拨清波");
                break;
            default:
                System.out.println("下面没有了");
                break;
        }
    }
}

  1. 注意

    switch能匹配byte、short、int、char、枚举类型、String类型的数据，不能匹配float和double型的数据，因为switch是精准匹配，不能精准的匹配到float和double类型。

3.1.2 case 的穿透性

  1. 如果没有break，就会出现case的穿透性，程序就一直往下穿透执行，知道遇到break或者switch代码执行完毕，就停止了

    import java.util.Scanner;

public class Demo02Switch {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int data = sc.nextInt();
        switch (data) {
            case 1:
                System.out.println("鹅鹅鹅");
                
            case 2:
                System.out.println("曲项向天歌");
                
            case 3:
                System.out.println("白毛浮绿水");
                
            case 4:
                System.out.println("红掌拨清波");
                break;
            default:
                System.out.println("下面没有了");
                break;
        }
    }
}

    结果：

    image-20240312163232055

public class Demo03Switch {
    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;
        }
    }
}

public class Demo03Switch {
    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;
        }
    }
}

3.2 if 语句的使用

3.2.1 if 第一种格式

  1. 格式

    if(boolean表达式) {
	执行语句;
}

或者

if(boolean表达式) 
	执行语句;

  2. 执行流程

    先走 if 后面的 boolean 表达式，如果是 true，就走 if 后面大括号中执行语句，否则就不走

  3. 注意

    if 后面跟的是 boolean 表达式，只要是结果为 boolean 型的，都可以放在小括号中，哪怕直接写一个 true 或者 false

public class Demo01If {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个数");
        int data1 = sc.nextInt();
        System.out.println("请输入第二个数");
        int data2 = sc.nextInt();

        if (data1 == data2) {
            System.out.println("两个整数相等");
        }
    }
}

3.2.2 if 的第二种格式

  1. 格式

    if(boolean 表达式) {
	执行语句1；
} else {
	执行语句2；
}

  2. 执行流程

    a.先走 if 后面的 boolean 表达式，如果是 true，就走 if 后面的执行语句1；

    b.否则就走 else 后面的执行语句2。

public class Demo02IfElse {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个数");
        int data1 = sc.nextInt();
        System.out.println("请输入第二个数");
        int data2 = sc.nextInt();

        if (data1 == data2) {
            System.out.println("两个整数相等");
        } else {
            System.out.println("两个整数不相等");
        }
    }
}

3.2.3 练习

  1. 需求：任意给出一个整数，请用程序实现判断该整数时奇数还是偶数，并在控制台输出该该整数是奇数还是偶数

    public class Demo03IfElse {
    public static void main(String[] args) {
      	/**
         * 需求：任意给出一个整数，请用程序实现判断该整数时奇数还是偶数，并在控制台输出该该整数是奇数还是偶数
         */
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数");
        int data = sc.nextInt();
        if (data%2 == 0) {
            System.out.println("您输入的是偶数");
        } else {
            System.out.println("您输入的是奇数");
        }
    }
}

  2. 需求：利用 if else 求出两个数的较大值

    public class Demo04IfElse {
    public static void main(String[] args) {
        /**
         * 需求：利用 if else 求出两个数的较大值
         */
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个数");
        int data1 = sc.nextInt();
        System.out.println("请输入第二个数");
        int data2 = sc.nextInt();

        if (data1 > data2) {
            System.out.println("较大值为：" + data1);
        } else {
            System.out.println("较大值为：" + data2);
        }
    }
}

  3. 案例：从键盘输入年份，请输出该年的2月份的总天数。闰年2月份29天，平年2月份28天。

    闰年：a.能被4整除，但不能被100整除；b. 或者能直接被400整除。

    步骤：

    1. 创建 Scanner 对象，调用 nextInt()键入一个年份 year
    2. 判断(year%4 == 0 && year % 100 != 0) || (year % 400 == 0)
    3. 如果条件成立，就输出闰年2月29天，否则输出平年2月28天
    public class Demo05IfElse {
    public static void main(String[] args) {
        /**
         * 案例：从键盘输入年份，请输出该年的2月份的总天数。闰年2月份29天，平年2月份28天。
         * 闰年：a.能被4整除，但不能被100整除；b. 或者能直接被400整除。
         */
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入年份");
        int year = sc.nextInt();
        if (year%4 == 0 && year%100 != 0 || year%400 == 0) {
            System.out.println(year + "年2月份的总天数为：29天");
        } else {
            System.out.println(year + "年2月份的总天数为：28天");
        }
    }
}

  4. public class Demo06IfElse {
    public static void main(String[] args) {
        boolean num1 = false;
        boolean num2 = true;
        
        int i = 1;
        /**
         * num1 = false
         * num2 = true
         * num1 = num2 → 相当于将num2的true赋值给num1
         */
        if (num1 = num2) {
            i++;
            System.out.println("i = " + i); // 2
        }
        if (false) {
            --i;
            System.out.println("i = " + i);
        }
    }
}

3.3.4 if 的第三种格式

  1. 格式

    if(boolean表达式) {
 执行语句1；
} else if（boolean表达式）{
 执行语句2；
} else if（boolean表达式）{
 执行语句3；
}
...
else {
 执行语句n；
}

  2. 执行流程

    从 if 开始往下挨个判断，哪个 if 判断结果为true，就走哪个 if 对应的执行语句，如果以上所有的判断都是 false，就走 else 对应的执行语句n

  3. 使用场景

    2 种以上的判断

public class Demo07ElseIf {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int data1 = sc.nextInt();
        int data2 = sc.nextInt();
        if (data1>data2) {
            System.out.println("data1大于data2");
        } else if (data1<data2) {
            System.out.println("data1小于data2");
        } else {
            System.out.println("data1等于data2");
        }
    }
}

注意：最后一种情况，不一定非得用 else，但是必须保证所有的情况都判断了

public class Demo07ElseIf {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int data1 = sc.nextInt();
        int data2 = sc.nextInt();
        if (data1>data2) {
            System.out.println("data1大于data2");
        } else if (data1<data2) {
            System.out.println("data1小于data2");
        } else if (data1 == data2) {
            System.out.println("data1等于data2");
        }
    }
}

3.3.5 练习

  1. 需求：键盘录入一个星期数（1，2，…7），输入对应的星期一，星期二，…星期日

    ​ 输入 1 输出 星期一

    ​ 输入2 输出 星期二

    ​ 输入3 输出 星期三

    ​ 输入4 输出 星期四

    ​ 输入5 输出 星期五

    ​ 输入6 输出 星期六

    ​ 输入7 输出 星期日

    ​ 输入 其他数字 输出 数字有误

    public class Demo08ElseIf {
    public static void main(String[] args) {
        /***
         * 需求：键盘录入一个星期数（1，2，...7），输入对应的星期一，星期二，...星期日
         *      输入 1   输出    星期一
         *      输入2    输出    星期二
         *      输入3    输出    星期三
         *      输入4    输出    星期四
         *      输入5    输出    星期五
         *      输入6    输出    星期六
         *      输入7    输出    星期日
         *      输入 其他数字   输出  数字有误
         */
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入数字");
        int week = sc.nextInt();
        /*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 {
            System.out.println("数字有误");
        }*/
        if (week<1||week>7) {
            System.out.println("数字有误");
        } else {
            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("星期日");
            }
        }
    }
}

  2. 根据最新的年龄段划分标准：

    0-6岁为婴幼儿

    7-12岁为少儿

    13-17岁为青少年

    18-45岁为青年

    46-69为中年

    69岁以上为老年

    请键盘录入一个年龄，判断属于什么年龄段

    public class Demo09ElseIf {
    public static void main(String[] args) {
        /***
         * 根据最新的年龄段划分标准：
         * 0-6岁为婴幼儿
         * 7-12岁为少儿
         * 13-17岁为青少年
         * 18-45岁为青年
         * 46-69为中年
         * 69岁以上为老年
         * 请键盘录入一个年龄，判断属于什么年龄段
         */
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入年龄");
        int age = sc.nextInt();
        /*if (age >=0 && age <=6) {
            System.out.println("婴幼儿");
        } else if (age >=7 && age <=12) {
            System.out.println("少儿");
        } else if (age >=13 && age <=17) {
            System.out.println("青少年");
        } else if (age >=18 && age <=45) {
            System.out.println("青年");
        } else if (age >=46 && age <=69) {
            System.out.println("中年");
        } else if (age > 69 && age <= 130) {
            System.out.println("老年");
        } else {
            System.out.println("年龄不太符合实际");
        }*/
        if (age< 0 || age > 130) {
            System.out.println("年龄不太符合实际");
        } else {
            if (age >=0 && age <=6) {
                System.out.println("婴幼儿");
            } else if (age >=7 && age <=12) {
                System.out.println("少儿");
            } else if (age >=13 && age <=17) {
                System.out.println("青少年");
            } else if (age >=18 && age <=45) {
                System.out.println("青年");
            } else if (age >=46 && age <=69) {
                System.out.println("中年");
            } else if (age > 69 && age <= 130) {
                System.out.println("老年");
            }
        }
    }
}

switch 和 if 的区别：debug

  1. switch：会直接跳到相应匹配的case
  2. if：从上到下挨个判断 → 实际开发主要用 if 做判断
package com.atguigu.d_if;

import java.util.Scanner;

public class Demo10IfSwitch {
    public static void main(String[] args) {
        /***
         * 需求：键盘录入一个星期数（1，2，...7），输入对应的星期一，星期二，...星期日
         *      输入 1   输出    星期一
         *      输入2    输出    星期二
         *      输入3    输出    星期三
         *      输入4    输出    星期四
         *      输入5    输出    星期五
         *      输入6    输出    星期六
         *      输入7    输出    星期日
         *      输入 其他数字   输出  数字有误
         */
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入数字");
        int week = sc.nextInt();
        /*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 {
            System.out.println("数字有误");
        }*/
        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;
        }
    }
}

第四章 循环控制语句

  1. 什么时候使用循环语句

    当我们发现一件事或者一段代码在反复执行，我们就可以考虑使用循环语句了

4.1 for循环的使用

4.1.1 格式

for(初始化变量, 比较, 布进表达式) {
  循环语句 → 哪段代码循环执行，就将哪段代码放到此处
}

4.1.2 执行流程

a. 先走初始化变量

b. 比较，如果是true，走循环语句，走步进表达式（初始化的变量的值进行变化）

c. 再比较，如果还是true，继续走循环语句，继续走步进表达式

d. 再比较，直到比较为false，循环结束

image-20240313015226554

比如：

public class Demo01For {
    public static void main(String[] args) {
        for (int i=0;i<3;i++){
            System.out.println("我爱Java");
        }
    }
}

image-20240313015722837

快捷键：次数.fori

4.1.3 练习

  1. for 循环：求1-3之间的数据和，并把求和结果输出到控制台

    步骤：

    1. 定义一个变量，用来接收两个数的和 sum
    2. 利用for循环将1-3表示出来
    3. 在循环的过程中，两两相加，将结果赋值给 sum
    4. 输出 sum
    public class Demo02For {
    public static void main(String[] args) {
        /***
         * for 循环：求1-3之间的数据和，并把求和结果输出到控制台
         */
        // 1.定义一个变量，用来接收两个数的和 sum
        int sum = 0;
        // 2.利用for循环将1-3表示出来
        for (int i = 1; i <= 3; i++) {
            // 3.在循环的过程中，两两相加，将结果赋值给 sum
            // sum += i;
            sum = sum + i;
        }
        // 4.输出 sum
        System.out.println("sum = " + sum);
    }
}

    image-20240313021238767

  2. 需求：求出1-100的偶数和

    public class Demo03For {
    public static void main(String[] args) {
        /***
         * 需求：求出1-100的偶数和
         */
        // 1.定义一个变量，用来接收两个数的和 sum
        int sum = 0;
        // 2.利用for循环将1-100表示出来
        for (int i = 1; i <= 100; i++) {
            // 3.在循环的过程中，如果是偶数，两两相加，将结果赋值给 sum
            if (i%2 == 0) {
                // sum += i;
                sum = sum + i;
            }
        }
        // 4.输出 sum
        System.out.println("1-100之间的偶数和为：" + sum);
    }
}

  3. 统计一下1-100之间的偶数个数

    public class Demo04For {
    public static void main(String[] args) {
        /***
         * 需求：统计一下1-100之间的偶数个数
         */
        // 1.定义一个变量，用来接收偶数个数
        int total = 0;
        // 2.利用for循环将1-100表示出来
        for (int i = 1; i <= 100; i++) {
            // 3.在循环的过程中，如果当前为偶数，total + 1
            if (i%2 == 0) {
                // total+=1;
                // ++total;
                total++;
            }
        }
        // 4.输出 total
        System.out.println("1-100之间的偶数个数为：" + total);
    }
}

4.2 while循环语句

4.2.1 格式

初始化变量;
while(比较) {
	循环语句;
	步进表达式
}

4.2.2 执行流程

  1. 初始化变量
  2. 比较，如果是true，走循环流程，走步进流程
  3. 再比较，如果是true，继续走循环流程，继续走步进流程
  4. 再比较，直到比较为false，循环结束
public class Demo01While {
    public static void main(String[] args) {
        int i = 0;
        while (i<5) {
            System.out.println("我爱Java");
            i++;
        }
    }
}

public class Demo02While {
    public static void main(String[] args) {
        int i = 1;
        int sum = 0;
        while (i<=3) {
            sum += i;
            i++;
        }
        System.out.println("sum = " + sum);
    }
}

public class Demo03While {
    public static void main(String[] args) {
        int i = 1;
        int sum = 0;
        while (i<=100) {
            if (i%2 == 0) {
                sum += i;
            }
            i++;
        }
        System.out.println("sum = " + sum);
    }
}

public class Demo04While {
    public static void main(String[] args) {
        int i = 1;
        int count = 0;
        while (i<=100) {
            if (i%2 == 0) {
                count++;
            }
            i++;
        }
        System.out.println("count = " + count);
    }
}

4.2.3 练习

需求：世界最高山峰是珠穆朗玛峰（8844.43米 = 8844430毫米），假如我有一张足够大的纸，它的厚度是0.1毫米。请问，我折叠多少次，可以折叠成珠穆朗玛峰的高度？27次

步骤：

  1. 定义一个变量表示山峰的高度 mountain

  2. 定义一个变量表示纸的厚度 paper

  3. 定义一个变量表示折纸的次数 count

  4. 利用while循环，循环比较，如果paper<mountain 就循环对折

    paper = paper * 2

    count ++;

  5. 输出 count

public class Demo05While {
    public static void main(String[] args) {
        // 1.定义一个变量表示山峰的高度 mountain
        int mountain = 8844430;
        // 2.定义一个变量表示纸的厚度 paper
        double paper = 0.1;
        // 3.定义一个变量表示折纸的次数 count
        int count = 0;
        // 4.利用while循环，循环比较，如果paper<mountain 就循环对折
        //   paper = paper * 2
        //   count ++;
        while (paper<mountain) {
            paper *= 2;
            count++;
        }
        // 5.输出 count
        System.out.println("count = " + count); // count = 27
    }
}

4.3 do…while循环语句(了解)

4.3.1 格式

初始化变量;
do {
  循环语句;
  步进表达式;
} while (比较)

4.3.2 执行流程

  1. 初始化变量
  2. 走循环语句
  3. 走步进表达式
  4. 判断，如果是true，继续循环，直到比较为false，循环结束

4.3.3 特点

至少循环一次

4.3.4 练习

public class Demo01DoWhile {
    public static void main(String[] args) {
        int i = 0;
        do {
            System.out.println("我爱Java");
            i++;
        } while (i<5);
    }
}

4.4 循环控制语句

循环控制有两个关键字：break、continue

4.1.1 break

  1. 在 switch中代表结束switch语句
  2. 在循环中代表结束循环

4.1.2 continue

结束当前本次循环，直接进入下一次循环，直到条件为false为止

4.1.3 练习

public class Demo01BreakContinue {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            if (i==3) {
                // 结束循环
                // break; // 我爱Java1 我爱Java2
                // 结束本次循环，进入下次循环
                 continue; // 我爱Java1 我爱Java2 我爱Java4 我爱Java5
            }
            System.out.println("我爱Java"+i);
        }

    }
}

4.5 死循环和嵌套循环

4.5.1 死循环

  1. 概述：一直循环
  2. 什么条件下一直循环：比较条件一直是 true
public class Demo01EndLess {
    public static void main(String[] args) {
        int count = 0;
        /*for (int i = 0; i < 10; ) {
            count ++;
            System.out.println("我爱Java" + count);
        }*/
        /*for (; ; ) {
            count ++;
            System.out.println("我爱Java" + count);
        }*/
        while (true) {
            count ++;
            System.out.println("我爱Java" + count);
        }
    }
}

4.5.2 嵌套循环

  1. 概述：循环中还有循环

  2. 执行流程

    先执行外层循环，再进入内层循环，内层循环就一直循环，直到内层循环结束，外层循环进入下一次循环，直到外层循环都结束了，整体结束

    public class Demo02Nest {
    public static void main(String[] args) {
        for (int minute = 0; minute < 60; minute++) {
            for (int second = 0; second < 60; second++) {
                System.out.println(minute+"分"+second+"秒");
            }
        }
    }
}

  3. 练习：打印矩形

    public class Demo03Nest {
    public static void main(String[] args) {
        // 外层循环控制行
        for (int i = 0; i < 5; i++) {
            // 内层循环控制列
            for (int j = 0; j < 5; j++) {
                System.out.print("*  ");
            }
            System.out.println();
        }
    }
}

  4. 练习：打印直角三角形

    public class Demo04Nest {
    public static void main(String[] args) {
        // 外层循环控制行
        for (int i = 1; i < 5; i++) {
            // 内层循环控制列
            for (int j = 0; j<i; j++) {
                System.out.print("*  ");
            }
            System.out.println();
        }
    }
}

  5. 练习：猜数字小游戏

    a. 创建Scanner 和Random对象

    b. 调用Random中的nextInt(100) +1,在1-100之间的随机一个数 rdNumber

    c. 调用Scanner 中的nextInt() 方法，键盘录入一个要猜的数 scNumber

    d. 如果 scNumber 大于 rdNumber，证明猜大了

    e. 如果 scNumber 小于 rdNumber，证明猜小了

    f. 如果 scNumber 等于 rdNumber，证明猜中了

    import java.util.Random;
import java.util.Scanner;

public class Demo01Exam {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Random rd = new Random();
        System.out.println("请输入猜测数字");
        int scNumber = sc.nextInt();
        int rdNumber = rd.nextInt(100) + 1;
        System.out.println("生成的随机数为：" + rdNumber);
        if (scNumber > rdNumber) {
            System.out.println("猜大了");
        } else if (scNumber < rdNumber) {
            System.out.println("猜小了");
        } else {
            System.out.println("猜中了");
        }
    }
}

    import java.util.Random;
import java.util.Scanner;

public class Demo01Exam {
    public static void main(String[] args) {
        //1.创建Scanner 和Random对象
        Scanner sc = new Scanner(System.in);
        Random rd = new Random();
        // 2.调用Random中的nextInt(100) +1,在1-100之间的随机一个数  rdNumber
        int rdNumber = rd.nextInt(100) + 1;
        while (true) {
            // 3.调用Scanner 中的nextInt() 方法，键盘录入一个要猜的数 scNumber
            System.out.println("请输入猜测数字");
            int scNumber = sc.nextInt();
            if (scNumber > rdNumber) { // 3.如果 scNumber 大于 rdNumber，证明猜大了
                System.out.println("猜大了");
            } else if (scNumber < rdNumber) { // 4.如果 scNumber 小于 rdNumber，证明猜小了
                System.out.println("猜小了");
            } else { // 5.如果 scNumber 等于 rdNumber，证明猜中了
                System.out.println("猜中了");
                break;
            }
        }
    }
}

总结

img

枫林残忆168
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

枫林残忆168

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值