JavaSE笔记02-流程控制、循环控制、Random

最新推荐文章于 2024-10-06 20:16:20 发布

杨1123

最新推荐文章于 2024-10-06 20:16:20 发布

阅读量76

点赞数

分类专栏： JavaSE 文章标签： java 算法

本文链接：https://blog.csdn.net/weixin_42089996/article/details/120603010

版权

JavaSE 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1. 分支管理

1.1 流程控制

流程控制语句分类

顺序结构

最简单最基本的控制流程，没有特定的语法结构，按顺序执行
执行顺序：开始→语句A→语句B→语句C→结束
代码示例

public class OrderDemo {
    public static void main(String[] args) {
        System.out.println("开始"); 
        System.out.println("语句A"); 
        System.out.println("语句B"); 
        System.out.println("语句C");
        System.out.println("结束");  
    }
}

分支结构 if switch

if语句1

格式：

if(关系表达式){
	语句体;
}

执行流程：
- 首先计算关系表达式的值
- 如果关系表达式的值为true，就执行语句体
- 如果关系表达式的值为false，就不执行语句体
- 继续执行后面内容
代码示例

public class IfDeno {
    public static void main(String[] args) {
        System.out.println("开始"); 
        int a = 10;
        int b = 20;
        if(a == b){
            System.out.println("相等");
        }
        System.out.println("不相等");

        int c = 10;
        if(a == c){
            System.out.println("相等");
        }
        System.out.println("结束");  
    }
}

if语句2

格式：

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

执行流程：
- 首先计算关系表达式的值
- 如果关系表达式的值为true，就执行语句体1
- 如果关系表达式的值为false，就执行语句体2
- 继续执行后面的内容
代码示例

public class IfDemo2 {
    public static void main(String[] args) {
        System.out.println("开始"); 
        int a = 10;
        int b = 20;
        if(a > b){
            System.out.println("a的值大于b");
        }else{
            System.out.println("a的值不大于b");
        }
        System.out.println("结束"); 
    }
}

if案例

奇偶数判断

import java.util.Scanner;
public class test3 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数字：");
        int i = sc.nextInt();
        if((i % 2) == 0){
            System.out.println("输入的数字为偶数");
        }else{
            System.out.println("输入的数字为奇数");
        }
    }
}

if语句3

格式：

if(关系表达式1){
	语句体1
}else if(关系表达式2){
	语句体2
}
……
else{
	语句体n
}

执行流程：
- 首先计算关系表达式1的值
- 如果值为true就执行语句体1，如果值为false就计算关系表达式2的值
- 如果值为true就执行语句体2，如果值为false就计算关系表达式3的值
- ……
- 如果没有关系表达式的值为true，就执行语句体n
代码示例

import java.util.Scanner;

public class IfDemo3 {
    public static void main(String[] args) {
        System.out.println("开始");
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个星期（数字1-7）：");
        int i = sc.nextInt();
        if(i == 1){
            System.out.println("星期一");
        } else if(i == 2){
            System.out.println("星期二");
        } else if(i == 3){
            System.out.println("星期三");
        } else if(i == 4){
            System.out.println("星期四");
        } else if(i == 5){
            System.out.println("星期五");
        } else if(i == 6){
            System.out.println("星期六");
        } else if(i == 7){
            System.out.println("星期七");
        } else {
            System.out.println("输入错误");  
        }

        System.out.println("结束");
        
    }
}

switch语句

格式：

switch(表达式){
	case 值1:
					语句体1;
					break;
	case 值2:
					语句体2;
					break;
	……
	default:
					语句体n;
					[break;]
}

格式说明：
- 表达式：取值为byte、short、int、char，JDK5以后可以是枚举，JDK7以后可以是String
- case：后面跟的是要和表达式进行比较的值
- break：表示中断，结束的意思，用来结束switch语句
- default：表示所有情况都不匹配的时候，就执行该内容，和if语句的else相似
执行流程
- 首先计算表达式的值
- 依次和case后面的值进行比较，如果有对应的值，就执行相应的语句，在执行的过程中，遇到break就结束。
- 如果所有的case后面的值和表达式都不匹配，就会执行default里面的语句体，然后程序结束
代码示例：

import java.util.Scanner;

public class SwitchDeno {
    public static void main(String[] args) {
        System.out.println("开始");
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个星期（数字1-7）：");
        int i = sc.nextInt();
        switch(i){
            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;
        }
    } 
}

注意事项：
- 在switch语句中，如果case控制的语句体后面不写break，将会出现穿透现象，在不判断下一个case的值情况下，向下运行，直到遇到break运行结束。

1.2 循环语句

循环语句
- for循环语句
  - 特征：
    - 重复做某件事
    - 有明确的开始和停止标志
  - 组成：
    - 初始化语句：用于标表示循环开启的起始状态，简答的说就是循环开始的时候什么样。
    - 条件判断语句：用于表示循环反复执行的条件，简单的说就是是否能一直执行下去。
    - 循环体语句：用于表示循环反复执行的内容，简单说就是反复执行的事情。
    - 条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去
  - 循环结构对应语法：
    - 初始化语句：这里可以是一条或多条语句，完成一些初始化操作
    - 条件判断语句：这里使用一个结果值为boolean类型的表达式，这个表达式能决定是否执行循环体
    - 循环体语句：这里可以是任意语句，这些语句将反复执行
    - 条件控制语句：这里通常是使用一条语句改变变量的值，从而达到循环控制是否继续效果。
  - 格式：
```
for(初始化语句;条件判断语句;条件控制语句){
		循环体语句;
}

死循环格式：（一直执行循环体语句）
for(;;){
	循环体语句
}
```
  - 执行流程
    - 执行初始化语句
    - 执行条件判断语句，结果是true还是false
      - true，继续执行
      - false，结束执行
    - 执行循环体语句
    - 执行条件控制语句
    - 回到第二步继续
  - 代码示例
```
public class ForDemo1 {
    public static void main(String[] args) {
        //在控制台输出多次HelloWorld
        for(int i = 1;i < 6;i++){
            System.out.println("HelloWorld");
        }
    }
}
```
- while循环语句
  - 格式：
```
基本格式：
while(条件判断语句){
	循环体语句;
}

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

死循环格式：
while(true){
	循环体语句;
	条件控制语句;
}
```
  - 执行流程
    - 执行初始化语句
    - 执行条件判断语句，看起结果是true还是false
      - 如果为false，循环结束
      - 如果为true，继续执行
    - 执行循环体语句
    - 执行条件控制语句
    - 回到第二步继续
  - 代码示例：
```
public class WhileDemo1 {
    public static void main(String[] args) {
        //在控制台输出5次HelloWorld
        //for循环实现
        for(int i = 0 ; i <= 5; i++){
            System.out.println("helloworld");
        }
        //while循环实现
        int i = 1;
        while(i<=5){
            System.out.println("HelloWorLD");
            i++;
        }
    }
}
```
- do…while循环语句
  - 格式：
```
基本格式：
do{
	循环体语句;
}while(条件判断语句);

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

死循环格式：
初始化语句;
do{
	循环体语句;
	条件控制语句;
}while(true);
```
  - 执行流程
    - 执行初始化语句
    - 执行循环体语句
    - 执行条件控制语句
    - 执行条件判断语句，看结果是true还是false
      - true，继续执行
      - false，循环结束
    - 回到第二步
  - 代码示例：
- 上述三种循环区别
  - 三种区别
    - for循环和while循环先判断是否成立，然后决定执行循环体
    - do…while循环先执行一次，在判断是否成立
  - for和while
    - 条件控制语句所控制的自增变量，属于for循环结构，在for循环结束后，就不能再访问到
    - 条件控制语句所控制的自增变量，对于while循环，不属于起语法结构，循环结束后仍然可以使用其变量
- 跳转控制语句
  - 概述：

在这里插入图片描述

    - continue用在循环中，基于条件控制，跳过某次循环体内的执行，继续下一次执行。
    - break用在循环中，基于条件控制，终止循环体内容的执行，也就是说结束当前整个循环
    - 代码示例：

    ```java
    public class ControlDemo {
        public static void main(String[] args) {
            for(int i = 1; i<= 5;i++){
                if(i%2 == 0){
                    // continue;//1  3  5
                    break;//1
                }
                System.out.println(i);
            }
            
        }
    }
    ```

- 循环嵌套
    - 语句顺序：
        - 顺序语句，以分号结尾，表示一句话结束
        - 分支语句
            - 一对大括号表示if整体结构，整体描述一个完整的if语句
            - 一对大括号表示switch整体结构，整体描述一个完整的switch语句
        - 循环语句
            - 一对大括号表示for整体结构，整体描述一个完整的for语句
            - 一对大括号表示while整体结构，整体描述一个完整的while语句
            - do...while以分号结尾，整体描述一个完整的do...while语句

1.3 Random

Random作用和使用步骤

作用，用于产生一个随机数
使用步骤
- 导包 import java.util.Random;
- 创建对象 Random r = new Random();
- 获取随机数 int number = r.nextInt(10);//获取数据范围，[0,10)
代码示例：

import java.util.Random;

public class RandomDemo {
    public static void main(String[] args) {
        Random r = new Random();
        for(int i = 0; i <10 ; i++){
            int unmber = r.nextInt(10);
            System.out.println(unmber);
        }
        //获取1-100之间的随机数
        int x = r.nextInt(100) + 1;
        System.out.println(x);

    }
}

猜数字游戏：

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

public class test4 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Random r = new Random();
        System.out.println("请输入1-100之间的任意数字：");
        int j = r.nextInt(100) + 1;
        while (true) {
            int i = sc.nextInt();
            if(i > j ){
                System.out.println("大了");
            }else if(i < j){
                System.out.println("小了");
            }else {
                System.out.println("中了");
                break;
            }
        }

    }
}