java 从入门到放弃 java从入门到入狱

转载

岁月如歌甚好 2023-12-27 10:09:26

文章标签 java 从入门到放弃 java java 零基础 System 流程控制 文章分类 Java 后端开发

文章目录

第五章、流程控制

5.1.流程控制的简介

5.1.1. 程序的执行结构
5.1.2. 流程控制的介绍

5.2. 分支流程控制 - if

5.2.1. if 流程图
5.2.2. if 基础语法
5.2.3. if 语法进阶

5.3. 分支流程控制 - switch

5.3.1. switch流程图
5.3.2. switch的基础语法
5.3.3. break

5.4. 循环流程控制 - for

5.4.1. for循环流程图
5.4.2. for循环基础语法
5.4.3. 特殊语法

5.5. 循环流程控制 - while

5.5.1. while循环基础语法
5.5.2. 示例代码
5.5.3. do-while循环

5.6. 两个关键字

5.6.1. break
5.6.2. continue

5.7. 循环标签

第六章、方法

6.1.方法的简介

6.1.1. 方法的概念
6.1.2. 为什么要使用方法

6.2. 方法的定义与调用

6.2.1. 方法的定义
6.2.2. 第一个方法
6.2.3. 方法的调用

6.3. 方法的参数

6.3.1. 参数的概念
6.3.2. 参数的定义
6.3.3. 有参方法的调用
6.3.4. 几个概念

6.4. 方法的返回值

6.4.1. 返回值的概念
6.4.2. 返回值的定义
6.4.3. return关键字

6.5. 方法的重载

6.5.1. 重载的概念
6.5.2. 重载方法的定义
6.5.3. 重载方法的调用

第七章、数组

7.1. 数组的概念

7.1.1. 一个案例
7.1.2. 数组是什么
7.1.3. 数组的特点

7.2. 数组的声明

7.2.1. 声明数组
7.2.2. 数组的实例化
7.2.3. 数组引用

7.3. 数组的下标

7.3.1. 下标的概念

7.3.2. 访问数组元素

7.3.3. 注意事项

7.4. 数组的遍历

7.4.1. 下标遍历
7.4.2. 增强for循环
7.4.3. 两种方式的对比

7.5. 数组的排序
7.6. 可变长参数

7.6.1. 概念
7.6.2. 语法
7.6.3. 使用

7.7. 二维数组

7.7.1. 概念
7.7.2. 定义与使用

7.8. Arrays工具类

7.8.1. 常用方法

第五章、流程控制

5.1.流程控制的简介

5.1.1. 程序的执行结构

在Java中，程序的执行结构分为三种

顺序结构：代码从上往下，逐行依次执行，是程序执行的默认结构。
分支结构：程序在某一个节点遇到了多种向下执行的可能性，根据条件，选择一个分支继续执行。
循环结构：某一段代码需要被重复执行多次。

5.1.2. 流程控制的介绍

流程控制，就是通过指定的语句，修改程序的执行结构。按照修改的不同的执行结构，流程控制语句可以分为：

分支流程控制语句：

将程序，由顺序结构，修改为分支结构

循环流程控制语句：

将程序，由顺序结构，修改为循环结构

5.2. 分支流程控制 - if

5.2.1. if 流程图

略

5.2.2. if 基础语法

if(condition){
    //代码块1
}else{
    //代码块2
}

逻辑: condition是一个boolean类型的变量, 或者一个boolean结果的表达式. 如果condition的值为true, 则代码段1执行, 否则, 代码段2执行

public class JavaSyntax {
    public static void main(String[] args) {
        int score = 99;
        if (score>=60){
            System.out.println("成绩及格！");
        }else {
            System.out.println("成绩不及格！");
        }
    }
}

5.2.3. if 语法进阶

if(condition1){
    //代码块1
}else if(condition2){
    //代码块2
}else{
    //代码块3
}

逻辑: 先判断condition1, 如果condition1成立, 执行代码段1; 如果condition1不成立, 再判断condition2, 如果condition2成立, 执行代码段2, 否则执行代码段3

public class JavaSyntax {
    public static void main(String[] args) {
        // 1. 定义一个成绩
        int score = 59;

        // 2. 将成绩划分成不同的等级
        //    < 0 || > 100 : 错误成绩
        //    [0, 60): 不及格
        //    [60, 80): 良
        //    [80, 90): 中
        //    [90, 100]: 优
        if (score < 0 || score > 100) {
            System.out.println("错误成绩");
        }
        else if (score < 60) {
            System.out.println("不及格");
        }
        else if (score < 80) {
            System.out.println("良");
        }
        else if (score < 90) {
            System.out.println("中");
        }
        else {
            System.out.println("优");
        }
    }
}

5.3. 分支流程控制 - switch

5.3.1. switch流程图

java 从入门到放弃 java从入门到入狱_流程控制

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JuidFe04-1594201665245)(C:\Users\Ba-Ba\Desktop\wps156.jpg)]

5.3.2. switch的基础语法

switch(变量){
	case值1：
        //分支语句1
    case值2：
        //分支语句2
     ......
        
    default:
}

程序逻辑：

检测某一个变量的值，从上往下依次与每一个case进行校验、匹配
如果变量的值和某一个case后面的值相同，则执行这个case后的语句
如果变量的值和每一个case都不相同，则执行default后的语句

5.3.3. break

public class Switch1 {
    public static void main(String[] args) {
        // 1. 定义一个变量, 记录第几个季节
        int season = 1;
        // 2. 根据season的值, 输出不同的季节
        switch (season) {
            case 1:
                System.out.println("春天");
            case 2:
                System.out.println("夏天");
            case 3:
                System.out.println("秋天");
            case 4:
                System.out.println("冬天");
            default:
                System.out.println("这是一个适合学习的季节");
        }
    }
}

上述代码中， switch结构捕获变量season的值。变量的值和第一个case是匹配的，应该输出的结果是 “春天”。但实际上的输出结果却是从春天开始的每一个输出。

因为在switch结构中有“穿透性”。

穿透性:

指的是，当switch的变量和某一个case值匹配上之后，将会跳过后续的case或者default的匹配，直接向后穿透。

java 从入门到放弃 java从入门到入狱_System_02

为了杜绝穿透，可以使用关键字 break:

这一段程序， season的值，和case1匹配。因此会输出“春天”，然后向下穿透，输出“夏天”。此时，遇到了关键字 break。将会结束穿透，直接结束switch结构。
因此，此时的输出结果是: 春天夏天

5.4. 循环流程控制 - for

5.4.1. for循环流程图

略

5.4.2. for循环基础语法

for(循环初始部分；循环条件；循环迭代部分){
    循环体
}

执行逻辑：

循环开始后，先执行循环初始部分，这一部分的代码只会执行一次。在初始部分，常常用于定义循环控制变量。
循环初始部分结束后，判断循环条件。
如果循环条件成立，执行循环体。
循环体执行结束后，执行循环迭代部分。这里常常用于对循环控制变量进行修改。
循环迭代部分执行结束，再回到第二步，判断循环条件。
如果循环条件成立，继续执行循环体。如果循环条件不成立，循环结束。

5.4.3. 特殊语法

循环体中的代码如果只有一句，大括号可以省略。但是从语法角度出发，可以省略，实际写程序的时候，出于规范，一般不省略。

public class For1 {
    public static void main(String[] args) {
        // 基础案例: 输出数字 1~100
        // for (int number = 1; number <= 100; number++) {
        //     System.out.println(number);
        // }

        // 基础案例: 输出[1,100]范围内的奇数
        // for (int num = 1; num <= 100; num++) {
        //     if (num % 2 != 0) {
        //         System.out.println(num);
        //     }
        // }
        // for (int num = 1; num <= 100; num += 2) {
        //     System.out.println(num);
        // }

        // 基础案例: 计算 1+2+3+4+...+100 = ?
        // 思路:
        // 定义一个变量, 用来记录累加的结果
        // 再将所有的数字依次累加到这个和里面
        int sum = 0;
        for (int n = 1; n <= 100; n++) {
            sum += n;
        }
        System.out.println(sum);
    }
}

for循环小括号中的每一部分都可以省略不写，但是分号不能省略。

for (int n = 1; n <= 100; n++) 
        System.out.println(n);

5.5. 循环流程控制 - while

5.5.1. while循环基础语法

while(循环条件){
    //循环体
}

程序逻辑：

如果循环条件条件成立，循环体循环执行。直到循环条件不成立。

5.5.2. 示例代码

public class JavaSyntax {
    public static void main(String[] args) {
        int n = 1;
        while (n < 100) {
            System.out.println(n);
        }
    }
}

5.5.3. do-while循环

do-while循环基本与while循环是一致的，只是在执行逻辑上稍微有点区别:

public class JavaSyntax {
    public static void main(String[] args) {
        int n = 1;
        do {
            System.out.println(n);
        } while (n < 100);
    }
}

执行逻辑:

先执行循环体，再判断循环条件是否成立。
如果循环条件成立，继续执行循环体。
如果循环条件不成立，结束循环。

5.6. 两个关键字

5.6.1. break

break用在循环中，表示无论循环条件是否成立，立即结束循环。

public class JavaSyntax {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            if (i == 5) {
                break;
            }
            System.out.println(i);
        }
    }
}

上述代码中，如果i的值为5，结束循环。所以，程序输出结果是

0
1
2
3
4

5.6.2. continue

continue用在循环中，表示立即停止本次循环，开始下次循环。

public class JavaSyntax {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            if (i == 6) {
                continue;
            }
            System.out.println(i);
        }
    }
}

当i的值是5的时候，停止当次的循环，立即进入下次循环。所以，程序输出的结果是

0
1
2
3
4
6
7
8
9

5.7. 循环标签

循环的实际使用中，有些情况下，需要使用到嵌套循环。在嵌套循环中，如果内层循环写了break或者continue，此时只能作用于内层的循环。

public class Loop {
    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            for(int j = 0;j<3;j++){
                if (j == 2){
                    break;
                }
                System.out.println("i="+i+",j="+j);
            }
        }
    }
}

上述代码中，当内层循环j的值为2的时候，结束内层循环。所以，程序的输出结果是

i = 0, j = 0
i = 0, j = 1
i = 1, j = 0
i = 1, j = 1
i = 2, j = 0
i = 2, j = 1
如果在内层循环中，需要使用break或者continue关键字作用于外层的循环，需要配合循环标签使用。
循环标签是一个标识符，常写成全大写。在循环的前面直接写标签，添加一个冒号即可。

public class Loop {
    public static void main(String[] args) {
        loop:for (int i = 0; i < 3; i++) {
            for(int j = 0;j<3;j++){
                if (j == 2){
                    break loop;
                }
                System.out.println("i="+i+",j="+j);
            }
        }
    }
}

上述代码中， break OUTER; 使得break关键字作用于指定的循环。此时，程序的输出结果是

i = 0, j = 0
i = 0, j = 1

第六章、方法

6.1.方法的简介

6.1.1. 方法的概念

在程序中，有些情况下，有些代码是需要被多次执行的。如果需要在每次使用到这些逻辑的时候，都去写代码实现，此时代码将会非常的冗余，不利于维护。

此时，我们可以将这些需要被多次执行的逻辑单独包装起来，在需要的时候直接调用即可。

方法，就是为了实现这个需求而存在的。

方法，其实就是一个实现特定功能的代码段，方法中的逻辑可以被重复使用。

6.1.2. 为什么要使用方法

可以使用方法，将需要多次执行的逻辑封装起来，哪里需要，哪里直接调用即可。

降低了代码的冗余，提高了代码的复用性与维护性。

6.2. 方法的定义与调用

6.2.1. 方法的定义

[访问权限修饰符][其他修饰符]返回值类型 方法名字([参数列表]){
    方法体
}

访问权限修饰符：定义了方法的访问权限。
其他的修饰符：定义了方法的其他的修饰。
返回值类型：定义了方法返回的值的类型。
方法名字：遵循小驼峰命名法的标识符。
方法体：需要封装起来的，可以被重复执行的代码段。

6.2.2. 第一个方法

//这个方法中，封装了一个九九乘法表
//哪里需要乘法表，哪里调用即可
public static void diaplay(){
    for (int line = 1;line<=9;line++){
        for (int colume = 1;colume<=9;colume++){
            System.out.println(colume+"x"+line+"="+colume*line+"\t");
        }
    }
}

6.2.3. 方法的调用

方法写完后，其中的逻辑并不会立即执行。如果想让程序中的逻辑执行，需要调用方法。

调用方法，直接使用方法的名字即可。

public class Test {
    public static void main(String[] args) {
        //方法的调用
        diaplay();
    }
    //这个方法中，封装了一个九九乘法表
    //哪里需要乘法表，哪里调用即可
    public static void diaplay(){
        for (int line = 1;line<=9;line++){
            for (int colume = 1;colume<=9;colume++){
                System.out.println(colume+"x"+line+"="+colume*line+"\t");
            }
        }
    }
}

6.3. 方法的参数

6.3.1. 参数的概念

多数情况下，方法与调用者之间需要进行数据的交互。调用者必须提供必要的数据，才能使用方法完成相应的功能。

例如:
ATM取款机，封装了取钱的功能。用户在使用ATM取款的时候，需要插入银行卡。此时，就是使用者与功能集的数据交互。
自动贩卖机，封装了贩卖的功能。用户在使用自动贩卖机的时候，需要选择购买的物品。此时，也是使用者与功能集的数据交互。

调用方法的时候，需要将一些数据传入到方法中，实现调用方与方法的数据交互。这个被传入到方法中的数据，被称为是参数。

6.3.2. 参数的定义

参数定义在方法的小括号中，与变量的定义类似，使用 [ 数据类型标识符 ] 的方式定义。

//定义了一个打印若干分隔符的方法，数量由参数count定义
public static void diaplay(int count) {
    for (int i = 0; i < count; i++) {
        System.out.println("-");
    }
    System.out.println();
}

定义参数的注意事项：

参数定义在方法的参数列表中，使用 [ 数据类型标识符 ] 的形式定义。
如果需要定义多个参数，多个参数之间以逗号分隔。
参数在定义的时候，不允许赋初始值。
即便多个参数的类型都是相同的，每一个参数也必须显式的定义类型。

6.3.3. 有参方法的调用

在调用有参方法的时候，必须给每一个参数进行赋值。直接将这些值写入到小括号里面即可。

public class Test {
    public static void main(String[] args) {
        //方法的调用
        diaplay(5);
    }

    //定义了一个打印若干分隔符的方法，数量由参数count定义
    public static void diaplay(int count) {
        for (int i = 0; i < count; i++) {
            System.out.println("-");
        }
        System.out.println();
    }
}

6.3.4. 几个概念

形参:

定义在方法的参数列表中，这样的参数只是一个形式。在方法中并不知道这个参数的值是什么，只有在调用的时候才知道具体的值是多少。
这样的参数被称为形式参数，简称形参

实参:

定义在方法调用时候的小括号中。这个参数是形参实际的值。
这样的参数被称为实际参数，简称实参

传参:

在调用方法的时候，实参给形参进行赋值。这个过程被称为传参

6.4. 方法的返回值

6.4.1. 返回值的概念

在进行方法调用的时候，有些情况下是需要有逻辑执行结果的。

例如
ATM取款机，用户在取完钱之后，一定是要能够得到实际的钱的。此时就是调用功能集得到的结果。

6.4.2. 返回值的定义

在前面定义方法的时候，返回值类型部分，写的是void。

void: 表示无，没有返回值。表示这个方法没有执行结果。

static int add(int a, int b){
    return a+b;
}

注意事项

如果一个方法的返回值类型不是void，则方法在执行结束之前，必须要有return关键字返回一个结果。

6.4.3. return关键字

表示方法的执行结果。
return关键字后面跟上方法的执行结果，这个值的类型，必须和方法定义中的返回值类型一致。

static int add(int a, int b){
    return a+b; //将a+b的运算结果，作为整个方法的执行结果。
}

表示结束方法的执行
在一个返回值类型为void的方法中，也可以使用return关键字。此时， return后面什么都不要写。
return写在方法中，表示结束方法的结束。

static int add(int a, int b){
    return a+b;
  //return执行后，后面的所有代码都不执行。
    //方法结束。
}

6.5. 方法的重载

6.5.1. 重载的概念

在一个类的方法中，如果多个方法满足如下条件，则他们之间的关系就是重载

方法名相同
参数不同

参数不同，体现在参数的数量不同或者参数的类型不同。

注意： 方法的重载，与返回值没有关系！

6.5.2. 重载方法的定义

public class Test {
    public static void calculate() {
    }

    public static void calculate(int a) {
    }

    public static void calculate(int a, int b) {
    }

    public static String calculate(String x, String y) {
        return x + y;
    }
}

6.5.3. 重载方法的调用

调用重载方法的时候，使用实参区分调用不同的方法。

public class Test {
    public static void calculate() {
    }

    public static void calculate(int a) {
    }

    public static void calculate(int a, int b) {
    }

    public static String calculate(String x, String y) {
        return x + y;
    }
    
    public static void main(String[] args) {
        calculate();//无参方法调用
        calculate(3);//一个参数方法调用
        calculate(3, 4);//两个整型参数方法调用
        calculate("a", "b");//两个字符串型参数方法调用
    }
}

第七章、数组

7.1. 数组的概念

7.1.1. 一个案例

如何存储100名学生的成绩

办法：使用变量存储，重复声明100个double类型的变量即可。
缺点：麻烦，重复操作过多。

如何让100名学生成绩全部+1

办法：100个变量重复相同操作，直到全部完毕。
缺点：无法进行统一的操作。

7.1.2. 数组是什么

数组，是一个数据容器。可以存储若干个相兼容的数据类型的数据。

在上述案例中，存储100名学生的成绩，可以用数组来完成。将这100个成绩存入一个数组中。此时对这些数据进行统一操作的时候，直接遍历数组即可完成。

7.1.3. 数组的特点

数组中可以存储基本数据类型的数据，也可以存储引用数据类型的数据。
数组的长度是不可变的。一个数组一旦实例化完成，长度不能改变。

7.2. 数组的声明

7.2.1. 声明数组

double[] arrar1;
int[] array2;
String[] array3

7.2.2. 数组的实例化

实例化数组：其实就是在内存中开辟空间，用来存储数据。

public class Test {
    public static void main(String[] args) {
        // 实例化了一个数组， 可以存储5个数据
        // 此时数组中的元素就是默认的5个0
         int[] array1 = new int[5];
        // 实例化了一个数组， 默认存储的是 1, 2, 3, 4, 5
        // 此时数组的长度， 由这些存储的数据的数量可以推算出来为5
        int[] array2 = new int[] { 1, 2, 3, 4, 5 };
        // 实例化了一个数组， 默认存储的是 1， 2， 3， 4， 5
        // 相比较于第二种写法， 省略掉了 new int[]
         int[] array3 = { 1, 2, 3, 4, 5 };
    }
}

7.2.3. 数组引用

数组的实例化的时候，需要使用到关键字new

数组，其实是在堆上开辟的连续的空间。例如 new int[5]，就是在堆上开辟5个连续的4字节空间。

然后，将堆上的内存地址，给栈上的引用进行赋值。

java 从入门到放弃 java从入门到入狱_System_04

7.3. 数组的下标

7.3.1. 下标的概念

下标，就是数组中的元素在数组中存储的位置索引。

注意：数组的下标是从0开始的，即数组中的元素下标范围是 [0, 数组.length - 1)

7.3.2. 访问数组元素

访问数组中的元素，需要使用下标访问。

public class Test {
    public static void main(String[] args) {
        //实例化一个数组
         int[] array = { 1, 2, 3, 4, 5 };
         //访问数组中的元素
         array[2] = 300;//将数组中的第2个元素修改为300
        System.out.println(array[2]);//此时输出的是300
    }
}

7.3.3. 注意事项

在访问数组中的元素的时候，注意下标的问题！

如果使用错误的下标访问数组中的元素，将会出现 ArrayIndexOutOfBoundsException 异常！

public class Test {
    public static void main(String[] args) {
        //实例化一个数组
         int[] array = { 1, 2, 3, 4, 5 };
         //访问数组中的元素
         array[10] = 300;//访问数组中下标为10的元素，此时数组的最大下标为4,会出现异常
    }
}

7.4. 数组的遍历

数组遍历：其实就是按照数组中元素存储的顺序，依次获取到数组中的每一个元素。

7.4.1. 下标遍历

思路：循环依次获取数组中的每一个下标，再使用下标访问数组中的元素

public class Test {
    public static void main(String[] args) {
        //实例化一个数组
        int[] array = {1, 2, 3, 4, 5};
        //使用下标遍历数组
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

7.4.2. 增强for循环

思路：依次使用数组中的每一个元素，给迭代变量进行赋值。

public class Test {
    public static void main(String[] args) {
        //实例化一个数组
        int[] array = {1, 2, 3, 4, 5};
        //使用下标遍历数组
        for (int ele : array) {
            System.out.println(ele);
        }
    }
}

7.4.3. 两种方式的对比

如果需要在遍历的同时，获取到数组中的元素下标，需要使用下标遍历法。
如果需要在遍历的同时，修改数组中的元素，需要使用下标遍历法。
如果仅仅是想要获取数组中的每一个元素，不需要下标，也不需要修改数组中的元素，使用增强for循环。因为这种方式，遍历的效率比下标遍历法高。

7.5. 数组的排序

排序，即排列顺序，将数组中的元素按照一定的大小关系进行重新排列。

在Java中，常见的排序有:

选择排序：固定值与其他值依次比较大小，互换位置。
冒泡排序：相邻的两个数值比较大小，互换位置。
JDK排序：java.util.Arrays.sort(数组); // JDK提供默认的升序排序

…

有兴趣的可自行百度。

7.6. 可变长参数

7.6.1. 概念

可以接收多个类型相同的实参，个数不限，使用方式与数组相同。

在调用方法的时候，实参的数量可以写任意多个。

7.6.2. 语法

数据类型…形参名（必须放到形参列表的最后位，且只能有一个）

ststic void show(int...parameters){
	//方法体
}

7.6.3. 使用

public class Test {
    public static void main(String[] args) {
        // int[] array = { 1, 2, 3 };
        // showArray(array);

        // 如果一个方法的参数，使用 ... 来定义，可以将这个数组中的元素，直接写到实参列表中
        // 注意事项:
        // 1. 在形参列表中，可变长度的参数，必须在形参列表的最后位
        // 2. 一个形参列表中，只能存在一个...修饰的可变长度参数
        showArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 0);
    }

    public static void showArray(int a, int... array) {
        for (int i : array) {
            System.out.println(i + ",");
        }
    }
}

7.7. 二维数组

7.7.1. 概念

二维数组，其实就是数组中嵌套数组。

二维数组中的每一个元素都是一个小的数组。

理论上来讲, 还可以有三维数组、四维数组，但是常用的其实就是二维数组。

7.7.2. 定义与使用

public class Array {
    public static void main(String[] args) {
        // 1. 实例化一个二维数组
        // 第一个中括号中的3: 二维数组中包含了三个一维数组
        // 第二个中括号中的5: 二维数组中的每一个一维数组长度为5 
        int[][] array = new int[3][5];
        // 使用双下标访问数组中的元素
        array[0][3] = 10;

        // 这里得到的，是二维数组的长度，3 
        System.out.println(array.length);
        // 2. 实例化一个二维数组
        // 第一个中括号中的3: 二维数组中包含了三个一维数组
        //  第二个中括号中什么都没有，代表现在二维数组中的三个元素是 null 
        int[][] array2 = new int[3][];
        array2[0] = new int[]{1, 2, 3};

        // 3. 通过初始值实例化一个二维数组
        int[][] array3 = {{1, 2, 3}, {1, 2, 3, 4, 5}, {2, 3, 4}};
    }
}

7.8. Arrays工具类

7.8.1. 常用方法

方法	描述
copyOf(int[] array, int newLength)	从原数组中拷贝指定数量的元素，到一个新的数组中，并返回这个新的数组
copyOfRange(int[] array, int from, int to)	从原数组中拷贝指定范围 [from, to) 的元素，到一个新的数组中，并返回这个新的数组
equals(int[] array1, int[] array2)	判断两个数组是否相同
fill(int[] array, int element)	使用指定的数据，填充数组
sort(int[] array)	对数组进行排序（升序）
binarySearch(int[] array, int element)	使用二分查找法，到数组中查询指定的元素出现的下标
toString(int[] array)	将数组中的元素拼接成字符串返回

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：linux 防火墙开放docker 部署的端口 linux防火墙开放22端口

下一篇：android13 wifi 休眠策略 wlan休眠策略哪个省电

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯