day11.异常

最新推荐文章于 2024-06-21 17:14:47 发布
最新推荐文章于 2024-06-21 17:14:47 发布
阅读量766 收藏 15
点赞数 7
分类专栏： java基础入门到精通 文章标签： java 开发语言 青少年编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46664968/article/details/138138497
版权
本文详细介绍了Java中的异常处理，包括编译时期异常和运行时期异常的区别，如何使用`throws`声明和`try...catch`处理异常，以及Object类的toString和equals方法的重写。此外，还涵盖了自定义异常和内存相关知识，以及finally关键字的使用和对象比较的最佳实践。
摘要由CSDN通过智能技术生成

day11.内部类_异常


今日重点:
  1.能分清编译时期异常和运行时期异常
  2.会使用throws处理异常
  3.会使用try...catch处理异常
  4.知道我们最终为啥要使用try...catch处理异常
  5.知道Object是谁
  6.知道Object中的toString方法作用以及重写toString方法之后的作用
  7.知道Object中的equals方法作用以及重写equals方法之后的作用

第一章.内存

1.this和super

在这里插入图片描述

2.static关键字内存图

在这里插入图片描述

第二章.异常

1.异常介绍

1.概述:代码出现了不正常的现象,在java中每一个异常都是java的一个一个的类,或者叫做异常对象
2.异常体系说明:
  Throwable:
     Error:错误 -> 好比是人得了癌症 -> 不能通过处理让代码变正常了,必须重新写
     Exception:异常(所有异常的父类) -> 好比是人得了感冒(能治) -> 可以通过处理,让代码变得正常
               a.编译时期异常:代码一写,jvm一编译,报红了 -> Exception以及Exception的子类(除了RuntimeException以及RuntimeException的子类)
                   
               b.运行时期异常:代码写的时候没事,但是已运行就报错(RuntimeException以及子类)

在这里插入图片描述

public class Demo01Exception {
    public static void main(String[] args){
        //Error
        //int[] arr1 = new int[999999999];//java.lang.OutOfMemoryError 
        
        //运行时期异常
        int[] arr2 = new int[3];
        System.out.println(arr2[3]);//ArrayIndexOutOfBoundsException
        
        /*
          编译时期异常-> 
          不是我们写的语法错误,
          而是人家底层给我们抛了一个编译时期异常对象,底层抛出的异常继承自Exception
          我们一用就出现了编译时期异常
         */
        //FileOutputStream fos = new FileOutputStream("day11_exception\\1.txt");
    }
}

1.ctrl+n -> 搜索所有的类(包括自己写的以及java提前定义好的)

2.异常出现的过程

在这里插入图片描述

3.创建异常对象(了解)

创建异常对象,是为了故意造异常,以便我们后续学处理异常

1.格式:
  throw new 异常对象()

public class Demo03Exception {
    public static void main(String[] args) {
        String s = "abc.txt";
        method(s);
    }

    public static void method(String s) {
        if (!s.endsWith(".txt")){
          //创建异常对象
            throw new NullPointerException();
        }
    }
}

4.异常处理方式(重点)

4.1 异常处理方式一_throws

1.格式:在参数后面
  throws 异常

public class Demo04Exception {
    public static void main(String[] args)throws FileNotFoundException {
        String s = "abc.txt1";
        /*
          method方法使用了throws异常处理方案
          往上抛异常,但是抛的是编译时期异常
          此异常让调用处接收了
          也就是说:method(s)接收了一个下面抛过来的编译时期异常
          所以此处爆红
         */
        add(s);

        System.out.println("删除功能");
        System.out.println("修改功能");
        System.out.println("查询功能");
    }

    public static void add(String s)throws FileNotFoundException {
        if (!s.endsWith(".txt")){
            //创建异常对象
            throw new FileNotFoundException();
        }
        System.out.println("我要执行");
    }
}

4.2 异常处理方式一_throws多个异常

1.格式:
  throws 异常1,异常2
      
2.注意:
  如果处理的多个异常之间,有子父类继承关系,我们可以直接抛父类异常
  如果不知道多个异常之间到底有没有子父类继承关系,我们可以直接抛Exception    

public class Demo05Exception {
    public static void main(String[] args)throws /*FileNotFoundException,*//*IOException*/Exception {
        String s = "abc.txt1";
        /*
          method方法使用了throws异常处理方案
          往上抛异常,但是抛的是编译时期异常
          此异常让调用处接收了
          也就是说:method(s)接收了一个下面抛过来的编译时期异常
          所以此处爆红
         */
        add(s);
    }

    public static void add(String s)throws /*FileNotFoundException,*//*IOException*/Exception {
        if (s==null){
            //创建异常对象
            throw new IOException("IO异常了");
        }

        if (!s.endsWith(".txt")){
            //创建异常对象
            throw new FileNotFoundException("文件找不到异常");//利用有参构造设置异常信息
        }

        System.out.println("我要执行");
    }
}

4.3 异常处理方式二_try…catch

1.格式:
  try{
      可能会出现异常的代码
  }catch(异常类型 对象名){
      处理异常的方案->开发中将异常信息保存到日志文件中
  }

public class Demo06Exception {
    public static void main(String[] args) {
        String s = "abc.txt1";
        try {
            //String s1 = null;
            //System.out.println(s1.length());//NullPointerException
            add(s);
        }catch (FileNotFoundException e){
            //如果try中的异常抓不到,try...catch外面的功能会受影响
            
            e.printStackTrace();//将异常详细信息打印出来
        }
        System.out.println("删除功能");
        System.out.println("修改功能");
        System.out.println("查询功能");
    }

    private static void add(String s) throws FileNotFoundException {
        if (!s.endsWith(".txt")) {
            throw new FileNotFoundException("文件找不到");
        }
        System.out.println("我要执行");
    }
}

4.4 异常处理方式二_多个catch

1.格式:
  try{
      可能会出现异常的代码
  }catch(异常类型 对象名){
      处理异常的方案->开发中将异常信息保存到日志文件中
  }catch(异常类型 对象名){
      处理异常的方案->开发中将异常信息保存到日志文件中
  }catch(异常类型 对象名){
      处理异常的方案->开发中将异常信息保存到日志文件中
  }...
      
2.注意:
  a.如果多个异常之间有子父类继承关系,先抓子类,再抓父类异常
  b.如果多个异常之间有子父类继承关系,我们可以直接抓父类异常

public class Demo07Exception {
    public static void main(String[] args) {
        String s = "abc.txt1";
        /*try {
            add(s);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e){
            e.printStackTrace();
        }*/

        //错误演示
        /*try {
            add(s);
        }catch (IOException e){
            e.printStackTrace();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }*/

        /*try {
            add(s);
        }catch (IOException e){
            e.printStackTrace();
        }*/

        try {
            add(s);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    public static void add(String s) throws FileNotFoundException, IOException {
        if (s == null) {
            //创建异常对象
            throw new IOException("IO异常了");
        }

        if (!s.endsWith(".txt")) {
            //创建异常对象
            throw new FileNotFoundException("文件找不到异常");//利用有参构造设置异常信息
        }

        System.out.println("我要执行");
    }
}

在这里插入图片描述

5.finally关键字

1.作用:一定会执行的代码块
2.使用:都是和try结合使用

public class Demo08Exception {
    public static void main(String[] args) {
        String s = "abc.txt1";
        try {
            method(s);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }finally {
            System.out.println("我一定要执行,爱谁谁!");
        }
    }
    public static void method(String s)throws FileNotFoundException{
        if (!s.endsWith(".txt")){
            throw new FileNotFoundException("文件找不到异常");
        }
    }
}

//结果:
//	java.io.FileNotFoundException: 文件找不到异常
// 	我一定要执行,爱谁谁!
//流程：
//	try: 接受method方法抛出异常,执行catch捕获异常并执行异常，最终执行finally代码

public class Demo08Exception {
    public static void main(String[] args) {
        String s = "abc.txt1";
        try {
            String s1 = null;
            System.out.println(s1.length());//NullPointerException
            method(s);
        }catch (FileNotFoundException e) {
            e.printStackTrace();
        }finally {
            System.out.println("我一定要执行,爱谁谁!");
        }
    }
    public static void method(String s)throws FileNotFoundException{
        if (!s.endsWith(".txt")){
            throw new FileNotFoundException("文件找不到异常");
        }
    }
}

//结果:
// 	我一定要执行,爱谁谁!
//	java.lang.NullPointerException
//流程：
//	try: 接收到s1变量操作出现异常，去catch：查看对于异常类型处理方案结果没有。进行往下执行finally代码。jvm发现还没有处理异常终止程序并将异常信息打印出来

public class Demo09Exception {
    public static void main(String[] args) {
        int result = method();
        System.out.println(result);
        /*
        执行顺序：
        	程序入门是main方法
        	调用method()执行method()方法
                执行try代码里
                    定义空字符串赋值给变量s
                    调用变量s的属性-》发现出现错误是“空指针异常”
                jvm捕获异常执行到catch里发现return关键字（结束当前方法） 下面finally关键字执行不
                    如果执行catch代码会导致程序结束，没办法执行到finally
                    所以先执行finally代码，后在去执行catch代码
        结果：
        	我一定要执行
        	1
        */
    }

    public static int method() {
        try {
            String s = null;
            System.out.println(s.length());//空指针异常
            return 2;
        } catch (Exception e) {
            return 1;
        } finally {
            System.out.println("我一定要执行");
        }

    }
}

finally的使用场景:关闭资源

​ 堆内存中的对象由GC(垃圾回收器)回收,但是有很多对象,如:IO流对象,网编 Socket对象,数据库连接对象(Connection)等,GC无法回收,既然GC没有办法回收,我们只能自己关闭资源,销毁对象,所以我们可以将关闭资源,销毁对象的操作放到finally中

6.抛异常时注意的事项(扩展)

1.父类中的方法抛了异常了,那么子类重写此方法之后要不要抛呢?
  可抛可不抛
    
2.父类中的方法没有抛异常,那么子类重写此方法之后要不要抛呢?
  不要抛

7.try_catch和throws的使用时机

1.如果处理异常之后,还想让后续的代码正常执行,我们使用try...catch
2.如果方法之间是递进关系(调用),我们可以先throws,但是到了最后需要用try...catch做一个统一的异常处理

在这里插入图片描述

1.运行时期异常一般我们不处理,因为一旦有运行时期异常出现,肯定是代码写的有问题

2.编译时期异常我们肯定要处理,不处理爆红,代码爆红了,不处理还继续往下写,没意义

8.自定义异常

1.需求:键盘录入一个用户名,实现登录功能,如果登录失败,抛出LoginUserException

public class Demo11Exception {
    public static void main(String[] args) throws LoginUserException {
        //1.创建Scanner对象
        Scanner scanner = new Scanner(System.in);
        System.out.println("请您输入要登录的用户名:");
        String username = scanner.next();
        //2.定义一个字符串,代表已经注册过的用户名
        String name = "root";

        //3.判断
        if (username.equals(name)){
            System.out.println("登录成功");
        }else{
            //如果失败了,就创建异常对象
            throw new LoginUserException("登录失败");
        }
    }
}

public class LoginUserException extends Exception /*RuntimeException*/{
    public LoginUserException() {
    }

    public LoginUserException(String message) {
        super(message);
    }
}

1.创建一个类

​ a.继承Exception,此时变成了编译时期异常

​ b.继承RuntimeException,此时变成了运行时期异常

2.提供构造方法,方便我们设置异常信息

9.打印异常信息的三个方法

Throwable中的方法:
    public String getMessage():获取异常的描述信息,原因(提示给用户的时候,就提示错误信息)
    public String toString():获取异常的类型和异常描述信息(不用)
    public void printStackTrace():打印异常的跟踪栈信息并输出到控制台上(最详细的异常信息)

public class Demo12Exception {
    public static void main(String[] args) {
        String s = "abc.txt1";
        try {
            method(s);
        } catch (FileNotFoundException e) {
            //System.out.println(e.getMessage());
            //System.out.println(e.toString());
            e.printStackTrace();
        }
    }
    public static void method(String s)throws FileNotFoundException{
        if (!s.endsWith(".txt")){
            throw new FileNotFoundException("文件找不到异常");
        }
    }
}

第三章.Object类

1.Object的介绍

1.概述:
  所有类的父类,根类,所有的类都会直接或者间接去继承Object类
      
2.注意:
  a.一个类如果没有明确写出extends xxx,那么此类默认的亲爹就是Object

2.Object类中的toString方法

小技巧:

1.按住ctrl不放,鼠标点击被调用的方法或者变量,可以快速跳到对应的方法以及变量的位置

2.ctrl+n 查询类

3.alt+7 查看当前类中的成员

1.Object中的toString方法  -> 返回对象的字符串表示形式
  public String toString() {
      return getClass().getName() + "@" + Integer.toHexString(hashCode());
  }

2.结论:
  a.如果一个类没有重写toString方法,直接输出对象名会默认调用Object中的toString方法,此时会输出地址值     这个地址值的组成形式就是Object中toString方法拼接成的形式
      
  b.如果一个类重写了Object中的toString方法,再返回地址值就没有意义了,所以我们重写toString之后,我们应该返回对象的内容    

public class Person{
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //重写toString

    @Override
    public String toString() {
        return name+","+age;
    }
}

public class Test01 {
    public static void main(String[] args) {
        Person p1 = new Person("柳岩",36);
        Person p2 = new Person("涛哥",18);
        System.out.println(p2);
        System.out.println(p1.toString());//com.atguigu.b_object.Person@135fbaa4
        System.out.println(p2.toString());//com.atguigu.b_object.Person@45ee12a7

        ArrayList<String> list = new ArrayList<>();
        list.add("abc");
        list.add("def");
        System.out.println(list);// [abc, def]
    }
}

结论:

1.如果直接输出对象名,不让其输出地址值,就在此对象中重写toString方法,让toString返回内容

2.怎么重写:

​ alt+insert->toString->ok

3.Object类中的equals方法

1.Object中的equals方法:
  public boolean equals(Object obj) {
      return (this == obj);
  }

2.注意:
  ==:
   a.针对于基本类型,比较的值
   b.针对于引用类型,比较的是地址值    
3.结论:
  a.如果没有重写Object中的equals方法,那么会调用Object中的equals方法,针对引用类型比较地址值
  b.如果重写Object中的equals方法,再比较地址值就没意义了,所以重写之后,我们应该比较对象的内容    

public class Person{
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //重写toString

   /* @Override
    public String toString() {
        return name+","+age;
    }*/

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }


    /**
     *
     * @param obj
     * @return
     *
     * 问题1:为啥用obj调用name和age报错? 因为此时obj为Object类型接收了Person类型的p2
     *      此处为多态,name和age是Person中的特有属性,多态前提下,不能直接调用子类特有成员,所以报错
     * 解决问题1:
     *      向下转型
     *
     * 问题2:如果传递的不是Person类型,会出现类型转换异常
     * 解决问题2:加个类型判断,如果传递过来的数据属于Person类型,在强转成Person类型
     *
     * 问题3:如果equals方法接收的是null,我们就没有必要判断类型了
     * 解决问题3:直接做非空判断,提高点效率
     *
     * 问题4:如果equals方法接收的是自己,就会出现自己和自己比较,自己跟自己比肯定为true,就没有必要
     *      判断类型,向下转型,比较了
     * 解决问题4:加判断,如果地址值一样,直接返回true
     *
     */
    /*public boolean equals(Object obj){
        if (this==obj){
            return true;
        }

        if (obj==null){
            return false;
        }

        if (obj instanceof Person){
            Person p2 = (Person)obj;
            return this.name.equals(p2.name) && this.age == p2.age;
        }

        return false;

    }*/

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }

}


public class Test02 {
    public static void main(String[] args) {
        Person p1 = new Person("柳岩",36);
        Person p2 = new Person("柳岩",36);
        //System.out.println(p1.equals(p2));

        //ArrayList<String> list = new ArrayList<>();
        //System.out.println(p1.equals(list));
        //System.out.println(p1.equals(null));
        System.out.println(p1.equals(p1));

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

        String s1 = new String("abc");
        String s2 = new String("abc");
        System.out.println(s1.equals(s2));//true
        System.out.println(s1==s2);//false
    }
}

在这里插入图片描述

结论:

1.如果比较两个对象,想比较对象的内容,就重写equals方法

2.怎么重写:alt+insert -> equals and hashCode -> 一路下一步->ok

阿斌嗑JAVA
关注
  • 7
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
day13_API-异常.pdf
11-02
Java 中的 Math、BigInteger 和 BigDecimal 类 Java 语言中提供了多种数学类来帮助开发者进行数学运算，包括 Math、BigInteger 和 BigDecimal 类。这些类提供了丰富的数学方法，帮助开发者快速高效地进行数学运算。...
Day03-异常.md
06-27
Java自学
Moment.js & Day.js 时间日期类库
超悠閒的博客
05-22 2084
Moment.js & Day.js 时间日期类库 文章目录Moment.js & Day.js 时间日期类库前言正文0. 环境配置0.1 安装依赖0.2 辅助工具函数1. Moment.js1.1 创建时间日期对象1.2 获取/设置属性1.3 日期操作(加、减、对齐、选择)1.4 查询(判断、比较)1.5 格式化输出2. Day.js2.1 创建时间日期对象2.1.1 差异2.2 获取/设置属性2.2.1 差异2.3 日期操作(加、减、对齐、选择)2.3.1 差异2.4 查询(判断、比较)
异常java.io.NotSerializableException
weixin_43859562的博客
10-25 6782
异常java.io.NotSerializableException
JAVA_SE基础——54.异常
脚本叔叔
11-22 1617
异常的体系： ----------| Throwable  所以异常或者错误类的超类 --------------|Error  错误   错误一般是用于jvm或者是硬件引发的问题，所以我们一般不会通过代码去处理错误的。 --------------|Exception 异常   是需要通过代码去处理的。 如何区分错误与异常呢： 如果程序出现了不正常的信息，如果不正常的信息的类名
【JAVA-Day68】异常处理的奥秘：深度解析 Java try-catch-finally 机制，高效应对异常问题
沉淀、分享、成长，让自己和他人都能有所收获！
12-18 1万+
在软件开发中，异常处理是保障程序稳定性的重要一环。本文将深入研究 Java 中的 try-catch-finally 机制，通过对每个环节的详细解析和实际案例演示，帮助读者更好地理解和应用异常处理的核心知识点。在某些情况下，我们可能需要抛出自定义异常来更好地表示特定的错误情况，以便于后续的处理。// 自定义异常的实现try {// 可能抛出异常的代码块if (/*某个条件*/) {throw new CustomException("发生自定义异常");// 处理自定义异常。
MySQL异常 DAY_OF_MONTH
qingcheng157的博客
12-09 1565
异常信息； Cause: java.sql.SQLException: DAY_OF_MONTH Error creating bean with name 'initCustomService': Invocation of init method failed; nested exception is com.alibaba.fastjson.JSONException: write javaBean error, fastjson version 1.2.73, class com.authine
day11-15
li13051517725的博客
03-07 4529
day11: could not produce class with ID 74 这个在unity编辑器正常而l2cpp异常那就是配置问题，修改assets下link.xml文件： <linker> <assembly fullname="UnityEngine.AnimationModule"> <type fullname="UnityEngine.AnimationClip"/> </assembly> .
Day202.前后端分离概念、讲师管理模块后端接口部分的开发、Swagger2配置、统一异常处理 -谷粒学院
阿昌爱Java
02-24 8472
谷粒学院 0、前后端分离概念 开发讲师管理模块后端 一、数据库设计 数据库 guli 数据表 CREATE TABLE `edu_teacher` ( `id` char(19) NOT NULL COMMENT '讲师ID', `name` varchar(20) NOT NULL COMMENT '讲师姓名', `intro` varchar(500) NOT NULL DEFAULT '' COMMENT '讲师简介', `career` varchar(500) DEF
java.lang.NoSuchMethodException异常处理方法
热门推荐
小猿的博客
02-20 4万+
java.lang.NoSuchMethodException意思是没有找到该方法。 第一种情况：根据提示查看方法是否存在 第二种：是访问的方法是受保护的，我们用getDeclaredMethod()来获取方法，getDeclaredMethod的作用是忽略权限修饰符。 //忽略访问权限修饰符,获取方法 Method method = this.getClass().getDeclaredMet...
day14_日期类_异常
m0_58073753的博客
03-07 1870
日期类，异常，练习
刻意练习：Python基础 -- Task08. 异常处理
老马的程序人生
10-29 786
背景 我们准备利用17天时间，将 “Python基础的刻意练习” 分为如下任务： Task01：变量、运算符与数据类型（1day） Task02：条件与循环（1day） Task03：列表与元组（2day） Task04：字符串与序列（1day） Task05：函数与Lambda表达式（2day） Task06：字典与集合（1day） Task07：文件与文件系统（2day） Task08：异常...
笔记day01.docx
09-10
随着时间的推移，C++不断演进，增加了模板、异常处理、命名空间等功能，并由ANSI和ISO进行了标准化。 【C++与C语言的区别】 C++与C语言的最大区别在于编程思维。C++采用面向对象编程，强调数据和函数的结合，提高...
day07【异常、线程】.md
05-31
异常、线程学习笔记
Spring_day03.pdf
03-01
【Spring_day03.pdf】文档主要讲解了Spring框架中的核心概念——面向切面编程(AOP)。AOP作为Spring的两大核心之一，与控制反转(IOC/DI)一起构成了Spring的强大功能。 ### 1. AOP简介 面向切面编程(AOP)是一种编程...
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 721
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
Day43
m0_67496588的博客
06-20 988
JSON，Ajax
Homebrew使用
最新发布
gghh2015的博客
06-21 200
具体参考：https://blog.csdn.net/m0_67402970/article/details/126434901。简介：https://www.jianshu.com/p/f4c9cf0733ea。2、查看安装路径：brew list maven。官网：https://brew.sh/
Java面试八股之简述JVM内存结构
u012151345的博客
06-20 802
在Java 8之前，永久代（Permanent Generation）是方法区的实现，之后被元空间（Metaspace）取代。总结来说，JVM内存结构设计精巧，通过区分线程私有和共享区域，以及细致划分各个区域的功能，确保了Java程序的高效、安全运行。每个线程都有自己的栈，用于存储方法调用时的信息，包括局部变量表、操作数栈、动态链接、方法出口等。方法区的一部分，存放编译期生成的各种字面量和符号引用，如字符串字面量、类名、方法名等。JVM中最大的一块内存区域，用于存储几乎所有的对象实例和数组。
sst.day.mean和sst.day.anom的区别
05-12
sst.day.anom表示海温的异常值，即某一时间点的海温与长期平均值的差异。这个变量可以用于描述海洋的短期变化和异常事件，比如厄尔尼诺现象和拉尼娜现象等。 因此，sst.day.mean和sst.day.anom是两个不同的概念，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值