2023.3.22——java分支运算符的学习day3_使用java语句录入考试成绩,根据成绩所在区间,程序打印出不同奖励机制-CSDN博客

本文链接：https://blog.csdn.net/qq_55947807/article/details/129716101

01-流程控制语句

介绍 : 通过一些语句, 来控制程序的执行流程
分类 :
- 顺序结构 : Java程序默认的执行结构
- 分支结构 : if , switch
- 循环结构 : for, while, do…while

02-分支语句-if

目标 : 今后的需求, 只要是涉及到判断, 就要联想到 if 语句
- 能够分析出, 使用哪一种格式.

if语句的第一种格式:

    if(判断条件){
        语句体;
    }

 执行流程:
        1. 执行() 中的判断条件, 看其返回的结果是true, false
        2. true : 执行 {} 中的语句体
        3. false : 不执行 {} 中的语句体

 注意事项:
        1. if语句 () 和 {} 之间不要写分号
        2. if语句 {} 中如果只有一条语句, {} 可以省略不写, 但是不建议!
        3. if语句 () 中, 无论简单还是复杂, 只要给它一个true, false, 就符合语法规则

if语句的第二种格式:

    if(判断条件){
        语句体1;
    }else{
        语句体2;
    }

执行流程:
    1. 执行 () 判断条件, 看其返回结果是true, false
    2. true : 执行语句体1
    3. false : 执行 else 里面的语句体2

if语句的第三种格式:

    if(判断条件1){
        语句体1;
    }else if(判断条件2){
        语句体2;
    }else if(判断条件3){
        语句体3;
    }
    ...
    else {
        语句体n+1;
    }

 执行流程:

    1. 执行判断条件1, 看其返回结果是true, false
            true : 执行语句体1, 结束整个if语句
            false : 进入第二步
    2. 执行判断条件2, 看其返回结果是true, false
            true : 执行语句体2, 结束整个if语句
            false : 进入第三步
            ...
    3. 如果给出的所有判断条件, 都是false,  将会执行最后的else, 语句体n+1

package com.itwx.test;

import java.util.Scanner;

public class IfTest1 {
    /*
        需求: 键盘录入考试成绩, 根据成绩所在的区间, 打印出不同的奖励机制

        95 ~ 100 : 奖励自行车一辆
        90 ~ 94 : 游乐场玩一次
        80 ~ 89 : 变形金刚一个
        80分以下 : 挨揍

        健壮性判断: 数据的合理性  0 ~ 100
     */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入考试成绩:");
        int score = sc.nextInt();

        if (score < 0 || score > 100) {
            System.out.println("请检查您输入的成绩, 是否是0~100之间");
        } else 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("挨揍");
        }
    }
}

package com.itwx.test;

import java.util.Scanner;

public class IfTest2 {
    /*
        if语句的嵌套, 实现考试奖励
     */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入考试成绩:");
        int score = sc.nextInt();

        if (score >= 0 && score <= 100) {

            // 代码要是能够进入这个大括号, 成绩绝对是 0 ~ 100 之间的
            // 只需要考虑, 该给什么奖励即可
            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("请检查您输入的成绩, 是否是0~100之间!");
        }
    }
}

03-switch语句

格式 :

switch(将要匹配的值){
	case 值1:
		语句体1;
		break;
	case 值2:
		语句体2;
		break;
	case 值3:
		语句体3;
		break;
	...
	default:
		语句体n+1;
		break;
}

1. 拿着switch() 中的值, 跟case给出的选项逐个进行匹配, 匹配成功, 就执行对应的语句体
    		随后再由break, 结束掉switch语句
2. 如果给出的所有case都匹配失败, 将会执行最后的default

注意事项 :
- case 后面的值不允许重复
- case 后面的值只能是常量, 不能是变量
- switch () 中可以接收的类型
  - 基本数据类型 : byte short char int
  - 引用数据类型 : jdk5版本开始可以是枚举, jdk7版本开始可以是String字符串
- 如果switch语句, 省略了break, 会开启case穿透现象
使用选择 :
- if : 适用于范围性的判断查找
- switch : 适用于固定值的匹配

04-for循环

目标 : 为什么要学习循环语句
- 回答 : 程序中有些逻辑代码, 需要重复的执行很多次, 就应该使用循环
- 用户输入密码, 3次输入机会
- 猜数字小游戏
for 循环格式 :

for(初始化语句; 判断条件; 条件控制语句){
	循环体语句;
}

初始化语句: 定义变量, 通过这个变量, 来控制循环
判断条件: 根据这个条件返回的结果, 决定循环是否要继续
循环体语句: 循环要重复执行的代码
条件控制语句: 改变变量的值

执行流程 :

1. 执行初始化语句, 在整个循环的过程中, 只执行一次
2. 执行判断条件, 看其返回结果是true, false
		false : 循环结束
		true : 进入第三步
3. 执行循环体语句
4. 执行条件控制语句
5. 回到2继续


for(int i = 1; i <= 3; i++){
	System.out.println("HelloWorld");
}

案例1 :

package com.itwx.test;

public class ForTest1 {
    /*
        需求: 在控制台打印数字 1~3 和 3~1
        ------------------------------------------

        积累思路:
                 1. 循环中, 用于控制循环的那个变量, 是可以放在循环体中继续使用
                 2. 循环的条件控制语句, 不要局限的认为只能是++
     */
    public static void main(String[] args) {

        for (int i = 1; i <= 3; i++) {
            // 思路: 打印的东西, 需要是一个变量, 不能是常量
            // 分析: 变量的变化过程  1  2  3  这个变化过程, 跟 i 是一样的
            System.out.println(i);
        }

        System.out.println("--------------------");

        for (int i = 3; i >= 1; i--) {
            System.out.println(i);
        }
    }
}

案例2 :

package com.itwx.test;

public class ForTest2 {
    public static void main(String[] args) {
        for (int i = 10; i >= 1; i--) {
            System.out.println("干饭倒计时:" + i + "秒");
        }
        System.out.println("终于等到了饭点, 干饭人干饭时间!");
    }
}

案例3 :

package com.itwx.test;

public class ForTest3 {
    /*
        需求：求1-100之间的偶数和，并把求和结果在控制台输出

        积累思路: 今后只要需求中, 看到了求和字样, 就要联想到求和变量.
     */
    public static void main(String[] args) {
        // 1. 定义求和变量 sum，准备记录累加的结果
        int sum = 0;
        // 2. 使用 for 循环，分别获取数据 1 – 100
        for (int i = 1; i <= 100; i++) {
            // i : 在循环中, 代表 1 ~ 100 之间的每一个数值
            // 3. 循环使用 if 语句，筛选出偶数数据
            if (i % 2 == 0) {
                // 4. 将每一个偶数数据，和 sum 变量进行累加
                sum += i;
            }
        }
        System.out.println("1~100之间的偶数和:" + sum);

        System.out.println("--------------------------");

        int result = 0;
        for (int i = 2; i <= 100; i += 2) {
            result += i;
        }
        System.out.println("1~100之间的偶数和:" + result);
    }
}

循环的注意事项 :

1. for循环 () 和 {} 之间不要写分号
2. for循环 {} 中定义的变量, 在每一轮循环结束后, 都会从内存中释放(消失)
3. for循环 () 中定义的变量, 在整个循环结束后, 会从内存中释放(消失)
4. 因为马虎造成的无限循环(死循环)
	- 排查循环条件

循环嵌套 :

今天其他内容全部掌握了, 再看循环嵌套
阅读循环嵌套 :
- 思路 : 先看内循环, 搞清楚内循环单独拿出来是什么效果, 再看外循环.
编写循环嵌套 :
- 将大问题拆解为小问题
  - 先搞定内循环
  - 再考虑外循环

package com.itwx.test;

public class ForTest7 {
    /*
        循环嵌套: 在循环中, 继续编写循环语句
        ----------------------------------------------

        阅读循环嵌套代码: 先搞清楚内循环干的事儿, 然后再看外循环

                举例: 内循环单独拿出来, 打印5次HelloWorld, 整个内循环被外循环包裹, 外循环, 循环了5次
                        -- 效果: 25次HelloWorld

        ----------------------------------------------

        编写循环嵌套代码:
                先把大问题, 拆成小问题
                先把内循环干的事儿, 解决!
                然后, 再写外循环
     */
    /*
        需求: 在控制台使用 * 打印4行5列矩形

        1. 使用循环, 打印1行5列
        2. 改进为4行5列
     */
    public static void main(String[] args) {

        // 外循环: 控制的是行数
        for(int i = 1; i <= 4; i++){
            // 内循环: 控制的是列数
            for(int j = 1; j <= 5; j++){
                System.out.print("*");
            }
            System.out.println();
        }

        // 掌握扎实: 先写内循环, 再用外循环包裹
    }
}

package com.itwx.test;

public class ForTest8 {
    /*
        需求: 使用 * 在控制台打印直角三角形

            *
            **
            ***
            ****
            *****

            *****
            ****
            ***
            **
            *

        1. 5行5列矩形
        2. 改进为直角三角形

     */
    public static void main(String[] args) {

        // 外循环控制行数
        for (int i = 1; i <= 5; i++) {
            // 内循环控制列数
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }

        System.out.println("----------------------");

        // 外循环控制行数
        for (int i = 5; i >= 1; i--) {
            // 内循环控制列数
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

package com.itwx.test;

public class ForTest9 {
    /*
        需求: 在控制台打印99乘法表

            1*1=1
            1*2=2 2*2=4
            1*3=3 2*3=6 3*3=9
            1*4=4 2*4=8 3*4=12 4*4=16
            1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
            ...

            乘号左边: 每一次都是从1开始, 逐个+1进行增长       ---> j
            乘号右边: 在所在行中, 数据都是不变的             ---> i

            1. 9行9列矩形
            2. 改进为直角三角形
            3. 改进为99乘法表

            - 今天学习循环嵌套, 是为了后期的内容做铺垫
     */
    public static void main(String[] args) {

        // 外循环: 行数
        for (int i = 1; i <= 9; i++) {
            // 内循环: 列数
            for (int j = 1; j <= i; j++) {
                System.out.print(j + "*" + i + "=" + j * i + "\t");
            }
            System.out.println();
        }

    }
}

05-while循环

格式 :

初始化语句;
while(判断条件){
	循环体语句;
	条件控制语句;
}

int i = 1;
while(i <= 10){
    System.out.println("HelloWorld");
    i++;
}

执行流程 :

1. 执行初始化语句, 在整个循环的过程中, 只执行一次
2. 执行判断条件, 看其返回结果是true, false
		false : 循环结束
		true : 进入第三步
3. 执行循环体语句
4. 执行条件控制语句
5. 回到2继续

挑for循环中的几个练习, 使用while实现

06-do…while循环 (了解)

格式 :

初始化语句;
do {
	循环体语句;
	条件控制语句;
}while(判断条件);

int i = 1;
do {
	System.out.pritnln("HelloWorld");
	i++;
}while(i <= 10);

执行流程 :

1. 执行初始化语句
2. 执行循环体语句
3. 执行条件控制语句
4. 执行判断条件
		看其返回结果是true, false
		false : 循环结束
		true : 回到2继续
		
- 特点 : 无论判断条件是否满足, 都至少会执行一次循环体

07-三种循环的对比

(for, while) : 先判断, 后执行
(do…while) : 先执行, 后判断

思路: do...while循环今后很少使用

for , while : 使用选择

本质来说没什么区别, for能够解决的问题, while都能解决, 反之也是一样

08-break和continue

break : 结束 (switch, 循环)
continue : 跳过 (循环)
注意事项 : break, continue, 下面不允许写代码, 因为执行不到, 属于无效的代码
细节 : 如果在循环嵌套当中, break, continue 默认只能操作内循环
- 想要人为控制, 可以使用标号

package com.itwx.ctrl;

public class LoopDemo {
    /*
        注意: break, continue如果遇到了循环嵌套, 默认操作的是内部循环

        ----------------------------------------------

        使用循环标号技术, 控制break, continue操作指定一层的循环
     */
    public static void main(String[] args) {

        lo:
        for(int i = 1; i <= 3; i++){
            for(int j = 1; j <= 3; j++){
                if(j == 2){
                    break lo;
                }
                System.out.println("HelloWorld");
            }
        }

    }
}

09-Random产生随机数

1. 找符咒
		import java.util.Random;
2. 召唤精灵
		Random r = new Random();
3. 指挥精灵干活
		int num1 = r.nextInt(10);     		// 0~9
		int num2 = r.nextInt(100) + 1;		// 1~100
		int num3 = r.nextInt(101);		    // 0~100

		---------------------------------
		
		20~80
		
	    int num = r.nextInt(61) + 20;

package com.itwx.test;

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

public class RandomTest {
    /*
        需求: 实现猜数字小游戏
        -----------------------------

        1. 在程序中使用Random, 产生一个1~100之间的随机数, 我们要猜的数据 (randomNum)
        2. 使用Scanner键盘录入, 我们自己猜的数据 (scNum)
        3. 比较
     */
    public static void main(String[] args) {
        Random r = new Random();
        Scanner sc = new Scanner(System.in);
        // 1. 在程序中使用Random, 产生一个1~100之间的随机数, 我们要猜的数据 (randomNum)
        int randomNum = r.nextInt(100) + 1;
        while(true){
            // 2. 使用Scanner键盘录入, 我们自己猜的数据 (scNum)
            System.out.println("请输入:");
            int scNum = sc.nextInt();
            // 3. 比较
            if (scNum > randomNum) {
                System.out.println("猜大了");
            } else if (scNum < randomNum) {
                System.out.println("猜小了");
            } else {
                System.out.println("恭喜,猜对了!");
                break;
            }
        }
        System.out.println("感谢您的使用, 再见!");
    }
}