方法的使用，数组的使用

最新推荐文章于 2024-09-20 15:32:13 发布
最新推荐文章于 2024-09-20 15:32:13 发布
阅读量206 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yalu_123456/article/details/88987682
版权

方法

  • Java里边叫方法，其实就是函数；自己编写一个函数定义好函数名，之后可以重复调用。
  • 为什么要有方法？
    觉得可以从重复性上来理解，段从程序需要重复使用，为了简洁高效，使用方法，只需调用方法，使得程序简洁高效；
  • 格式：
    修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2 …){
    方法体;
    return 返回值;
    }
    (1): 修饰符 比较多,后面会详细介绍。目前使用 public static
    (2): 返回值类型 用于限定返回值的数据类型
    (3): 方法名 就是一个名称，它的存在是为了方便我们调用方法
    (4): 参数类型 限定调用方法时传入参数的数据类型
    (5): 参数名 是一个变量，接收调用方法时传入的参数
    这个参数其实有一个专业的名词,被称之为形式参数,它的作用是用来接收实际参数的.
    (6): 方法体 完成功能的代码
    (7): return 结束方法以及返回方法指定类型的值
    (8): 返回值 就是功能的结果，由return带回，带回给调用者

案例

案例一：

package org.westos.demo2;
public class MyTest {
    public static void main(String[] args) {
        System.out.println("abc");
        //直接调用我们自己定义的方法
        fashe();
        fashe();
        fashe();
        fashe();
        fashe();
        fashe();
        fashe();
    }
    public static void fashe(){
        //方法体，你具体要实现的功能
        System.out.println("发射炮弹");

    }

}

注意：

  1. 主方法，是一个程序的入口。主方法是JVM来调用的，一个类中只能有一个主方法
  2. 方法：就是对一段功能逻辑的封装，以实现重复调用。
  3. 方法定义在类中，方法跟方法是平级关系，不能嵌套定义
  4. 方法不调用不执行

案例二：

package org.westos.demo2;

public class MyTest2 {
    public static void main(String[] args) {
        //show();
        //show();
        int num = add2();
        System.out.println(num);
    }

    //void 无明确反回值类型
    public static void show() {
        System.out.println("微微一笑，很倾城");
    }

    //定义一个相加的功能
    public static void add() {
        System.out.println(1 + 1);
    }

    //我明确了这个方法的返回值类型是int类型
    //如果一个方法一旦明确了返回值类型，必须由 return 带回一个 与明确了类型一致的结果
    public static int add2() {
        int sum = 1 + 1;
        return sum;  //return 结束方法，并带回一个结果
    }
}

注意

  1. void无明确返回值类型
  2. 如果一个方法一旦明确了返回值类型，必须由 return 带回一个 与明确了类型一致的结果；
    案例三：
package org.westos.demo2;

public class MyTest3 {
    public static void main(String[] args) {
        System.out.println("主方法");
       int r= add(1,2);//当我们去调用一个有参数的方法时，必须传入与之相对应的参数（参数个数要对应，数据类型要对应）
        int aa=10;
        int bb=20;
        //当我们在调用方法时，传入的参数，叫做实际参数，简称实参，传常量，变量都可以
       int r2 =add(aa,bb);
        System.out.println(r);
        System.out.println(r2);

    }
    //定义方法括号里面的参数，叫做形式参数，简称形参。
    //形参的作用是，调用方法时，接收传过来的实参
    //多个形参你用逗号隔开
    public static int add(int a1,int b1){
        System.out.println("add方法执行了");
        int sum=a1+b1;
        return sum ;
    }

}

案例四：

package org.westos.demo2;

public class MyTest4 {
    public static void main(String[] args) {
        show();
        int r=show2();
        System.out.println(r);
        //如果一个方法有返回值，我们可以输出调用，打印返回的结果
        System.out.println(show2());
    }
    public static void show(){
        System.out.println("我在人民广场，吃着炸鸡");
        return; //结束方法 如果一个方法的返回值类型，是void 那么这个return 可以省略
    }
    public static int show2() {
        return 100; //结束方法 如果一个方法的返回值类型，是void 那么这个return 可以省略
    }
}

注意

  1. return功能是结束方法并且返回函数值；
  2. 对于返回的函数值，如果函数定义为void则为无明确返回值类型，return可以省略；

案例五：
需求：获取两个数中最大的数

package org.westos.demo3;

import java.util.Scanner;

public class MyTest {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入第一个整数");
        int num1 = scanner.nextInt();
        System.out.println("请输入第二个整数");
        int num2 = scanner.nextInt();
        int max = getMax(num1, num2);
        System.out.println("最大值是" + max);
    }

    public static int getMax(int a, int b) {
        int max = a > b ? a : b;
        return max;
    }
}

注意
（IntelliJ idea_64）

  1. alt+enter 万能纠错键
  2. ctrl+alt+v 自动补全
  3. alt+enter 选第一项也会补全

案例六：
需求：输入两个值判断是否相等

package org.westos.demo3;

import java.util.Scanner;

public class MyTest2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个数字");
        int num1 = sc.nextInt();
        System.out.println("请输入第二个数字");
        int num2 = sc.nextInt();
        //获取，输出 是两个概念
        boolean flag = isEquals(num1, num2); //调用方法

        if (flag) {
            System.out.println("相等");
        } else {
            System.out.println("不相等");
        }


    }

    public static boolean isEquals(int a, int b) {

        boolean flag = false;
        if (a == b) {
            flag = true;
        } else {
            flag = false;
        }
        return flag;
    }
}

方法使用注意事项

  1. 方法不调用不执行
  2. 方法与方法是平级关系，不能嵌套定义
  3. 方法定义的时候参数之间用逗号隔开
  4. 方法调用的时候不用在传递数据类型
  5. 如果方法有明确的返回值，一定要由return带回一个值

案例七：
方法调用之新型输出
需求：根据键盘录入的数据输出对应的乘法表

package org.westos.demo3;


import java.util.Scanner;

public class MyTest3 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个行数");
        int i = sc.nextInt();
        //调用方法
        showChengFaBiao(i);
    }

    public static void showChengFaBiao(int a) {
        for (int i = 1; i <= a; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(j + "*" + i + "=" + (j * i) + "\t");
            }
            System.out.println();
        }
    }
}

注意“\t”为空一个tab距离

案例八：
需求：输入行列数并打印出指定行列的*阵

package org.westos.demo3;

import java.util.Scanner;

public class MyTest4 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入行数");
        int num= scanner.nextInt();
        System.out.println("请输入列数");
        int num2 = scanner.nextInt();
        showStar(num,num2);

    }

    private static void showStar(int num, int num2) {
        for (int i = 0; i <= num; i++) {
            for (int i1 = 0; i1 <= num2; i++) {
                System.out.print("*");
            }
            System.out.println();
        }

    }
}

方法的重载和基本使用

  • 在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同，与返回值无关。
    参数列表不同：
    A:参数个数不同
    B:参数类型不同

案例九：

package org.westos.demo4;

public class MyTest {
    public static void main(String[] args) {
        //求和案例
        //2 个整数
        //3 个整数
        //4 个整数
        int sum1=add1(1,2);
        int sum2 = add2(1, 2,3);
        int sum3 = add3(1, 2,3,4);

        System.out.println(sum1);
        System.out.println(sum2);
        System.out.println(sum3);
    }

    private static int add(int i, int i1) {
        System.out.println("两个int参数方法调用了");
        return i + i1;
    }

    /**private static double add(int i, double i1) {
        System.out.println("一个int 一个double调用了");
        return i + i1;
    }*/

    private static int add(int i, int i1, int i2, int i3) {

        return i + i1 + i2 + i3;
    }

    private static int add(int i, int i1, int i2) {

        return i + i1 + i2;
    }


}

注意

  1. 方法重载：允许一个类中，可以出现多个同名方法，只要他们的参数个数不同，或者参数类型不同，就构成重载,不拿返回值类型来区分

数组

  • 数组的作用
    现在需要统计某公司员工的工资情况，例如计算平均工资、找到最高工资等。假设该公司有80名员工，
    用前面所学的知识，程序首先需要声明80个变量来分别记住每位员工的工资，然后在进行操作，这样做会显得很麻烦。
    为了解决这种问题，Java就提供了数组供我们使用
    结论：
    数组是存储多个变量(元素)的东西(容器)
    这多个变量的数据类型要一致
  • 数组定义：
    数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
    数组既可以存储基本数据类型，也可以存储引用数据类型。
  • 数组定义格式
    格式1： 数据类型[] 数组名；
    格式2： 数据类型 数组名[];
    举例：
    int[] a； 定义了一个int类型的数组a；
    int a[]; 定义了一个int类型的a数组；
    推荐使用第一种定义方式

数组初始化

  • 为什么要初始化
    Java中的数组必须先初始化,然后才能使用。
    所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
  • 初始化分类：
    a:动态初始化: 只指定长度，由系统给出初始化值
    b:静态初始化: 给出初始化值，由系统决定长度
    注意事项： 这两种方式，只能使用一种，不能进行动静结合
  • 动态初始化格式：
    数据类型[] 数组名 = new 数据类型[数组长度];
    数组长度其实就是数组中元素的个数。
    举例： int[] arr = new int[3]; 定义了一个int类型的数组arr，这个数组可以存放3个int类型的值。

案例

package org.westos.demo2;

public class ArrayDemo {
    public static void main(String[] args) {

        //方式1：
        //创建一个int类型的数组
     
        int[] arr=new int[10];
        //往数组中放入数据 通过数组的索引往里面存数据
        arr[0]=10;
        arr[1]=20;
        arr[2]=30;
        //取数组中的元素
        int num=arr[2];
        System.out.println(num);
        System.out.println(arr[4]);
        System.out.println(arr[5]);

        //语法2
        boolean bs[]=new boolean[2];
        bs[0]=true;
        System.out.println(bs[0]);
        System.out.println(bs[1]);


    }
}

注意

  1. 动态的定义方式，由我们规定数组的长度，由系统赋默认值
  2. 当我们创建好了数组后，系统会给分配索引（角标）从0开始（默认赋值）

Java中的内存分配以及栈和堆的区别

A:栈: 存放的是局部变量
局部变量：在方法定义中或者方法声明上的变量都是局部变量。
B:堆: 存放的是所有new出来的东西
特点：
a: 每一个new出来的东西都会为其分配一个地址值。
b: 每一个变量都有一个默认的值
byte，short，int，long – 0
float，double – 0.0
char – ‘\u0000’
boolean – false
引用数据类型 – null
c: 使用完毕就变成了垃圾，等待垃圾回收器对其回收
C:方法区

案例

案例一;

package org.westos.demo3;

public class ArrayDemo {
    public static void main(String[] args) {
        double[] arr = new double[10]; //动态初始化
        System.out.println(arr[0]);
        System.out.println(arr[9]);
    }
}

总结：由结果我们可以看出动态初始化：为数组中的数组元素分配内存空间，并为每个数组元素赋值默认值为0；

案例二：

package org.westos.demo4;

public class ArrayDemo2 {
    public static void main(String[] args) {
        int[] arr1 = new int[3];
        arr1[0]=10;
        arr1[2]=200;
        int[] arr2 = new int[3];
        arr2[0]=11;
        arr2[1]=19;
        int[] arr3=arr1;
        arr3[0]=108;
        arr3[1]=106;
        arr1[1]=177;
        System.out.println(arr1[0]); //  108
        System.out.println(arr1[1]); // 177
        System.out.println(arr1[2]); // 200
        System.out.println(arr2[0]); // 11
        System.out.println(arr2[1]); // 19
        System.out.println(arr2[2]); // 0
        System.out.println(arr3[0]); // 108
        System.out.println(arr3[1]); // 177
        System.out.println(arr3[2]); // 200
    }
}

注意
通过输出值我们可以理解数组栈、堆、方法区及内存分配过程。数组内存分配过程理解

数组操作的两个常见小问题越界和空指针

  • a:ArrayIndexOutOfBoundsException:数组索引越界异常
    原因：你访问了不存在的索引。
  • b:NullPointerException:空指针异常
    原因：数组已经不在指向堆内存了。而你还用数组名去访问元素。

案例

案例一：

package org.westos.demo5;
public class ArrayDemo {
    public static void main(String[] args) {
        //数组静态初始化，由我们赋值，由系统计算长度
        //数组一旦定义号，长度就固定了
        int[] arr = new int[]{10, 20, 30};
        boolean[] arr2 = new boolean[]{true, false, true, true};
        char[] arr3 = new char[]{'a', 100, 'b'};
        byte[] bytes = new byte[]{127, 100, 0, -128};
        long[] longs = new long[]{1L, 100L};
        float[] floats = new float[]{1F, 2.9F};

        //静态初始化的简写方式
        int[] arr6 = {10, 20, 30};

        //数组有一个长度属性
        int length = arr.length;
        System.out.println(length);
        int length1 = arr2.length;
        System.out.println(length1);
       // 数组中最后一个元素的索引=数组长度-1;
       int num=bytes[bytes.length-1];
        System.out.println(num);
        //关于数组的一些一异常
        arr[3]=100;
       // System.out.println(arr[3]); //ArrayIndexOutOfBoundsException 数组角标越界异常

    }
}

案例二：

package org.westos.demo5;

public class ArrayDemo2 {
    public static void main(String[] args) {
        int[] arr = new int[]{10, 20};
        arr = null;// 人为置空
        //NullPointerException 空指针异常
        int length = arr.length;
        System.out.println(length);
    }
}

数组的遍历

案例一：

package org.westos.demo6;


public class ArrayDemo {
    public static void main(String[] args) {
        int[] arr={10,20,50,40,102};
       
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("---------------------------");
        //反向遍历
        for(int i=arr.length-1;i>=0;i--){
            System.out.println(arr[i]);
        }

    }
}

案例二：
求数组中元素极值

package org.westos.demo6;

public class ArrayDemo2 {
    public static void main(String[] args) {
        //获取数组中的最大值或最小值
        int[] arr = {10, 20, 50, 40, 102};
        int max = getMax(arr);
        System.out.println("最大值是" + max);

        int[] arr2 = {10, 20, 50, 40, 102,1000,1};
        int max1 = getMax(arr2);
        System.out.println("最大值是" + max1);
    }

    public static int getMax(int[] arr){

        //定义一个参照值
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }
}

案例三：
数组元素反转

package org.westos.demo6;

public class ArrayDemo3 {
    public static void main(String[] args) {

        int[] arr = {10, 20, 30, 40, 50}; //50 40 30 20 10

        for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
            int t = arr[i];
            arr[i] = arr[j];
            arr[j] = t;
        }

        //reverseArray(arr);
        showArray(arr);


    }

    //数组元素反转
    private static void reverseArray(int[] arr) {
        //分析：首尾元素值交换，遍历一半
        for (int i = 0; i < arr.length / 2; i++) {
            //采用中间变量进行值交换
            int t = arr[i];
            arr[i] = arr[arr.length - 1 - i];
            arr[arr.length - 1 - i] = t;

        }
    }

    private static void showArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + ",");
        }
    }


}

案例四：
需求：根据键盘录入索引, 查找对应星期

package org.westos.demo7;

import java.util.Scanner;

public class ArrayDemo8 {
    public static void main(String[] args) {

        String[] arr = {"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期天"};
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个整数 1----7");
        int index = scanner.nextInt();
        String str = getElementByArray(index, arr);
        System.out.println(str);
    }

    private static String getElementByArray(int index, String[] arr) {
        if (index >= 1 && index <= 7) {
            return arr[index - 1];
        } else {
            return "查无此元素";
        }
    }
}

案例五：
根据元素查索引

package org.westos.demo7;

import java.util.Scanner;

public class ArrayDemo9 {
    public static void main(String[] args) {
     
        String[] arr = {"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期天"};
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个星期");
        String str = scanner.nextLine();//获取用户输入的字符串
        int index = getIndex(str, arr);

        System.out.println("该元素的索引是" + index);
        
    }

    private static int getIndex(String str, String[] arr) {
        //遍历数组

        for (int i = 0; i < arr.length; i++) {
            if (str.equals(arr[i])) {
                return i;
            }

        }
        return -1; // 一般喜欢用 -1 代表没找到
    }
}
dream_Felix
关注
C语言之数组的定义及其使用方法
m0_64365419的博客
05-29 1万+
数组是一组相同类型元素的集合，数组的创建方式： 数组类型 数组名 数组长度的大小（常量表达式） 例如：int arr[10]; √ int count=10; int arr2[count];×（必须是常量表达式） Char arr3[10];√ Float arr4[11];√ Double arr5[20];√ 数组元素的初始化 int arr[10]={1,2,3};这种叫做不完全初始化，剩下没有给定初始值的元素默认初始值为0.，字符数组同理也是如此。 不过字符串数组比较特殊，在部分初始化之后，没有初
JSONArray转换Long[]
chengmin123456789的博客
06-18 2165
直接使用下列代码转换的时候会出现 java.lang.ArrayStoreException: null 这样的异常，调用copy propertis 会复制不了属性 Long[] longs = new Long[]{}; return jsonArray.toArray(longs); 不得已做了下中间转换，才正常 Long[] longs = new Long[]{}; JSONArray jsonArray= JSON.parseArray(text); List<Long> long
Java笔试题解（7）
bwf_erg的博客
05-22 292
1： A.       10 B.       9 C.       0 D.       运行时错误 答案:D 解析: 本题考察能够使用一维数组实现数据存储，数组是从0开始的，最大为数组长度-1，所以没有num[num.length]，应该为num[num.length-1]，选择D 2： A.       2 4 6 0 B.       2 4
方法中的使用以及数组定义
weixin_47229643的博客
07-31 333
方法中的使用以及数组定义 方法中可能首先会定义一些数组，这是就会区分静态数组还是动态数组 数组定义： 其中静态数组定义方式如下： int[] arr = new int[]{1,2,3}; int[] arr = {1,2,3}; ----> 简化格式 其中动态数组定义方式如下： int [] arr = new int[3]; 左边： int:说明数组中的元素类型是int类型 []:说明这是一个数组 arr:这是数组的名称
Vue介绍及使用
yalu_123456的博客
08-09 271
Vue.js 是什么 Vue (读音 /vjuː/，类似于 view) 是一套用于构建用户界面的渐进式框架。 与其它大型框架不同的是，Vue 被设计为可以自底向上逐层应用。 Vue 的核心库只关注视图层，不仅易于上手，还便于与第三方库或既有项目整合。 另一方面，当与现代化的工具链以及各种支持类库结合使用时，Vue 也完全能够为复杂的单页应用提供驱动。 Vue准备 了解关于 HTML、CSS 和...
matlab中怎么使用数组,matlab中数组的基本使用
weixin_29115107的博客
03-17 4631
一数组的构造(1)用中括号[]>> x=[1,2,3]x =1 2 3(2)利用first:increment:last创建数组>> x=1:1:3x =1 2 3>> x=1:3 %也可以这样用，increment默认为1x =1 2 3(3)利用函数linspace:linspace(first_val,la...
python一维数组使用方法_Python之数组(array)使用方法总结与Numpy中的数组用法
weixin_39613385的博客
12-22 1823
array使用方法： Type code C Type Minimum size in bytes ‘c’ character 　　　 　　　　 1 ‘b’ signed integer 　　　　　 1 ‘B’ unsigned integer 　　　　　 1 ‘u’ Unicode character 　　　　　 2 ‘h’ signed integer 　　　　　　 2 ‘H’ ...
vue中使用数组方法push
热门推荐
m0_50926596的博客
09-06 1万+
具体写法可以有两种： 第一种：在函数内部声明变量， var company = [], hushu = [], bili = []; console.log("company",company,"hushu",hushu,"bili",bili); for(var i = 0 ;i<arr.length;i++){ company.push(arr[i].company); hushu.push(arr[i].hushu); bili.push(arr[i].dianscale
数组遍历的方法有哪些
夏天的博客
04-14 1万+
数组遍历的方法有8种 1、forEach：遍历开始以后无法停止，如果要遍历整个数组，那就使用这个方法； 2、map：根据当前数组映射出一个新的数组； 3、some：遍历整个数组，返回值true就停止循环（返回false继续循环） 返回值：如果数组中的有一项回调函数返回true，那么结果为true，否则为false；（或者这样理解：数组别遍历完，那么结果为false，否则为true） 4、every：与some相反，返回false就停止循环（返回true就继续循环） 5、filter：过滤数组，返回一个新的数
数组的常用方法大全
vue888的博客
09-14 1677
数组的常用方法
TIA博途中数组Array【】的基本使用方法详解.docx
10-08
- S7-1200 V4.2开始，支持多重背景中使用数组形式，即Array of FB。 - 这样可以在FB中使用循环指令更方便地编写程序。 - 不支持Array[*] of FB的形式。 9. **多维数组降维使用**： - 多维数组可以降维使用。 -...
Java实验-数组的定义、初始化方法 掌握数组的遍历方法 掌握Arryas类的使用
05-22
Java实验-数组的定义、初始化方法 掌握数组的遍历方法 掌握Arryas类的使用 Java实验报告中，主要讨论了数组的定义、初始化方法、数组的遍历方法和Arryas类的使用。下面是详细的知识点总结： 一、数组的定义和初始...
JavaScript中使用数组方法汇总
10-22
JavaScript数组是特殊的对象，用于在单个变量名下存储多个值。JavaScript数组的创建、元素...上述知识点汇总了在JavaScript中处理数组时可能会使用到的主要方法和属性，熟练掌握这些对于进行有效的数组操作十分关键。
JavaScript使用pop方法移除数组最后一个元素用法实例
10-24
在本篇文章中，我们将详细探讨pop方法的用法，并通过实例来演示如何在JavaScript中使用pop方法来移除数组的最后一个元素。 首先，pop方法是JavaScript数组对象的一种方法，它会移除数组中的最后一个元素，并返回这...
Java-网络
2301_81543552的博客
09-14 791
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Java企业面试题3
m0_74972727的博客
09-15 825
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
上传文件到钉盘流程详解
jspyth的博客
09-14 810
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
JDK17新增语法特性
最新发布
2201_76124988的博客
09-20 336
从springboot3.0开始，已经不支持JDK8，转变为JDK17参考资料：官方博客。
faiss安装 （CPU版本）
CSDN_WHB的博客
09-20 127
faiss版本 faiss-v1.7.4。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值