盘点Java中遇到的异常

最新推荐文章于 2024-08-19 18:56:17 发布
最新推荐文章于 2024-08-19 18:56:17 发布
阅读量952 收藏
点赞数 1
分类专栏： 笔记 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45699237/article/details/122627260
版权

目录

一、异常类型

1. 除0异常

2. 空指针异常

3. 数组下标越界

二、避免异常的两种方式

1. LBYL

2. EAFP

三、异常的基本用法

捕获异常的基本语法

代码示例1 不处理异常

代码示例2 使用 try catch 后的程序执行过程

代码示例3 catch 只能处理对应种类的异常

代码示例4 catch 可以有多个

代码示例5 也可以用一个 catch 捕获所有异常(不推荐）

代码示例6 finally 无论是否存在异常,都会执行的代码块！

代码示例7 finally 异常的返回值

代码示例8 关于异常的调用链

代码示例9 JDK7新增的自动关闭接口

代码示例10 关键字 throws

代码示例11 关键字 throw

四、Java异常体系

Java的异常体系分为两大类

非受查异常

受查异常

自定义异常类

五、内部类

1.成员内部类

2.内部类的使用方法/规则

一、异常类型

1. 除0异常

eg 👇

public class ExceptionTest {
    public static void main(String[] args) {
        int a = 10;
        int b = 0;
        System.out.println(a/b);
   }
}

2. 空指针异常

eg 👇

public class ExceptionTest {
    public static void main(String[] args) {
        String str = null;
        System.out.println(str.equals("test"));
   }
}

3. 数组下标越界

eg 👇

public class ExceptionTest {
    public static void main(String[] args) {
        int[] arr = {10,20,30};
        System.out.println(arr[10]);// 数组下标越界，下边的代码不执行
        System.out.println(arr[1]);
    }
}

二、避免异常的两种方式

1. LBYL

Look Before You Leap. 在操作之前就做充分的检查。

2. EAFP

It's Easier to Ask Forgiveness than Permission. "事后获取原谅比事前获取许可更容易". 也就是先操作, 遇到 问题再处理。

三、异常的基本用法

捕获异常的基本语法

try{ 
 有可能出现异常的语句 ; 
}[catch (异常类型 异常对象) {
} ... ]
[finally {
 异常的出口
}]
  • try 代码块中放的是可能出现异常的代码.
  • catch 代码块中放的是出现异常后的处理行为.
  • finally 代码块中的代码用于处理善后工作, 会在最后执行.
  • 其中 catch 和 finally 都可以根据情况选择加或者不加 .

代码示例1 不处理异常

int[] arr = {1, 2, 3};
System.out.println("before");
System.out.println(arr[100]);
System.out.println("after");

// 执行结果
before
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100

代码示例2 使用 try catch 后的程序执行过程

int[] arr = {1, 2, 3};
try {
    System.out.println("before");
    System.out.println(arr[100]);
    System.out.println("after");
} catch (ArrayIndexOutOfBoundsException e) {
    // 打印出现异常的调用栈
    e.printStackTrace();
}
System.out.println("after try catch");

// 执行结果
before
java.lang.ArrayIndexOutOfBoundsException: 100
 at demo02.Test.main(Test.java:10)
after try catch

关于 "调用栈" 方法之间是存在相互调用关系的, 这种调用关系我们可以用 "调用栈" 来描述. 在 JVM 中有一块内存空间称为 "虚 拟机栈" 专门存储方法之间的调用关系. 当代码中出现异常的时候, 我们就可以使用 e.printStackTrace(); 的 方式查看出现异常代码的调用栈。

代码示例3 catch 只能处理对应种类的异常

int[] arr = {1, 2, 3};
try {
    System.out.println("before");
    arr = null;
    System.out.println(arr[100]);
    System.out.println("after");
} catch (ArrayIndexOutOfBoundsException e) {
    e.printStackTrace();
}
System.out.println("after try catch");

// 执行结果
before
Exception in thread "main" java.lang.NullPointerException
 at demo02.Test.main(Test.java:11)

 此时, catch 语句不能捕获到刚才的空指针异常. 因为异常类型不匹配。

代码示例4 catch 可以有多个

public class ExceptionTest {
    public static void main(String[] args) {
        int[] arr = {10,20,30};
        try{
           arr = null;
            System.out.println(arr[10]);
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println("数组下标越界！");
        }catch (NullPointerException e){
            System.out.println("空指针异常！");
        }
        System.out.println("异常之后的代码");
    }
}

//执行结果
空指针异常！
异常之后的代码

一段代码可能会抛出多种不同的异常, 不同的异常有不同的处理方式. 因此可以搭配多个 catch 代码块. 

如果多个异常的处理方式是完全相同, 也可以写成这样

catch (ArrayIndexOutOfBoundsException | NullPointerException e)   { ... }

代码示例5 也可以用一个 catch 捕获所有异常(不推荐）

public class ExceptionTest {
    public static void main(String[] args) {        
        int[] arr = {10,20,30};
        try{
            arr = null;
            //假设此时有可能会出现10种部不同可能的异常
            System.out.println(arr[10]);
        }catch (Exception e){//只要发生异常就可以向上转型变为Exception对象
            System.out.println("异常发生了！");
        }
        System.out.println("异常之后的代码");
    }
}

//执行结果
异常发生了！
异常之后的代码

 由于 Exception 类是所有异常类的父类. 因此可以用这个类型表示捕捉所有异常。

改进版👇

public class ExceptionTest {
    public static void main(String[] args) {
        int[] arr = {10,20,30};
        try{
            //假设此时有可能会出现10种部不同可能的异常
            System.out.println(arr[10]);
        }catch(ArrayIndexOutOfBoundsException e){
            //此处e就是异常对象，默认有JVM产生传递给catch代码段
            System.out.println("数组越界了！");
            //printStackTrace() 打印错误堆栈信息
            e.printStackTrace();
        }
        System.out.println("异常之后的代码");
    }
}

//执行结果
数组越界了！
异常之后的代码
java.lang.ArrayIndexOutOfBoundsException: 10
	at errorCode.ExceptionTest.main(ExceptionTest.java:33)

代码示例6 finally 无论是否存在异常,都会执行的代码块！

public class ExceptionTest {
    public static void main(String[] args) {
        int[] arr = {10,20,30};
        try{
            //假设此时有可能会出现10种部不同可能的异常
            System.out.println(arr[10]);
            System.out.println("异常之后的代码");
        }catch(ArrayIndexOutOfBoundsException e){
            //此处e就是异常对象，默认有JVM产生传递给catch代码段
            System.out.println("数组越界了！");
            //printStackTrace() 打印错误堆栈信息
            e.printStackTrace();
        }finally {
            System.out.println("finally代码块的代码！");
        }
    }
}

//执行结果
数组越界了！
finally代码块的代码！
java.lang.ArrayIndexOutOfBoundsException: 10
	at errorCode.ExceptionTest.main(ExceptionTest.java:33)

 运行发现，无论异常是否产生，finally代码块中的内容一定执行，那么我们就将资源关闭操作等重要操作放在finally最终执行的代码——善后处理。以打开文件为例：👇

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class ExceptionTest {
    public static void main(String[] args) {
//File 是 Java文件中操作类
        File file = new File ("test.txt");
        //输入，将文件内容输入到Scanner中。不是从键盘输入
        Scanner scanner = null;
        try {
            scanner = new Scanner(file);
            System.out.println("文件正确加载完毕");
        }catch (FileNotFoundException e){
            System.out.println("文件不存在！");
            e.printStackTrace();
        }finally {
            System.out.println("文件正常处理完毕");
        }
    }
}

//执行结果
文件不存在！
文件正常处理完毕

能走到 finally，说明 try 和 catch 中的逻辑已经处理完毕了，只剩 finally 的最后处理操作。

代码示例7 finally 异常的返回值

public class ExceptionTest {
    public static void main(String[] args) {
        System.out.println(testException());
    }
    public static int testException(){
        try{
            String str = null;
            System.out.println(str.equals("123"));
            return 1;
        }catch (NullPointerException e){
            return 2;
        }finally {
            System.out.println("finally中的代码段");
            return 3;
        }
    }
}

//执行结果
finally中的代码段
3

一旦finally中带了返回值，相当于try和catch的返回值就失效了，无论是否有异常产生，finally- 定会执行，因此会覆盖try和catch的返回值。
在finally中不推荐写返回值，除非返回值和异常无关，默认返回值就可放在finally中。

代码示例8 关于异常的调用链

public class ExceptionTest {
    public static void main(String[] args) {
       try{
           exceptionChain();
       }catch (ArrayIndexOutOfBoundsException e){
           System.out.println("越界异常");
           e.printStackTrace();
       }
    }
    public static void exceptionChain(){
        int[] arr = new int[3];
        System.out.println(arr[10]);
    }

    public static int testException(){
        try{
            String str = null;
            System.out.println(str.equals("123"));
            return 1;
        }catch (NullPointerException e){
            return 2;
        }finally {
            System.out.println("finally中的代码段");
            return 3;
        }
    }
}

//执行结果
越界异常
java.lang.ArrayIndexOutOfBoundsException: 10
	at errorCode.ExceptionTest.exceptionChain(ExceptionTest.java:71)
	at errorCode.ExceptionTest.main(ExceptionTest.java:63)

ps: 第一行报错做关键，是程序最开始出错的地方。

代码示例9 JDK7新增的自动关闭接口

一旦一个类实现了AutoCloseable接口，就表示该类具备了自动关闭的能力-声明在try代码块中会
自动调用close方法。  try(此处创建自动关闭类的实例) {}

public class ExceptionTest {
    public static void main(String[] args) {
        try (CloseTest closeTest = new CloseTest()) {

        } catch (Exception e) {

        }
    }
}
class CloseTest implements AutoCloseable {
    public void close() throws Exception {
        System.out.println("close方法正常执行结束……");
    }
}

//执行结果
close方法正常执行结束……

代码示例10 关键字 throws

用在方法声明上，明确表示该方法有可能会产生该异常，但是不处理此异常，抛回给调用者处理

public class ExceptionTest {
    public static void main(String[] args) {
        try {
            test();
        }catch (NullPointerException e){
            System.out.println("捕获空指针异常！");
            e.printStackTrace();
        }
    }

    public static void test() throws NullPointerException,ArrayIndexOutOfBoundsException{
        String str = null;
        System.out.println(str.length());
    }
}

//执行结果
捕获空指针异常！
java.lang.NullPointerException
	at errorCode.ExceptionTest.test(ExceptionTest.java:82)
	at errorCode.ExceptionTest.main(ExceptionTest.java:73)

代码示例11 关键字 throw

用在方法内部，人为产生异常对象并抛出。

public class ExceptionTest {
    public static void main(String[] args) {
        fun();
        System.out.println("fun之后的代码");
    }
    public static void fun(){
        //人为产生一个空指针异常对象，抛出给调用者
        throw new NullPointerException("抛出一个异常~");
        //抛出异常后，方法就会结束
    }
}

//执行结果
Exception in thread "main" java.lang.NullPointerException: 抛出一个异常~
	at errorCode.ExceptionTest.fun(ExceptionTest.java:84)
	at errorCode.ExceptionTest.main(ExceptionTest.java:79)

四、Java异常体系

其中Error指的是Java运行时内部错误和资源耗尽错误，应用程序不抛出此类异常。这种内部错
除了告知用户并使程序终止之外,再无能无力，这种情况很少出现。
Exception 是我们程序猿所使用的异常类的父类。
Error : 指的是程序的内部错误，这种错误我们程序员无法捕获处理，一旦发生Error错误，程序只能告知用户出现错误，程序直接退出。
StackOverflowError : 栈溢出Error 一般发生在递归调用链太深，递归没有出口。
OutOfMemoryError : 堆溢出Error。

public class ExceptionTest {
    public static void main(String[] args) {
        System.out.println("fun之后的代码");
        recursion();
    }
    public static void recursion() {
        recursion();//递归调用
    }
}

//执行结果
fun之后的代码
Exception in thread "main" java.lang.StackOverflowError
	at errorCode.ExceptionTest.recursion(ExceptionTest.java:91)

Java的异常体系分为两大类

非受查异常

所有的非受查异常不强制程序使用try catch块处理。Error以及RuntimeException(运行时异常,空指针，类型转换，数组越界)及其子类都是非受查异常。如下代码所示👇

public class ExceptionTest {
    public static void main(String[] args) {
        test();
        try {
            test1();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
    public static void test1() throws FileNotFoundException {
        File file = new File("test1.text");
        Scanner scanner = new Scanner(file);
    }
    // 调用test方法有可能会产生空指针异常，但是test方法不处理此异常，谁调用谁处理
    // 空指针和数组越界异常都属于非受查异常，可以不显示的进行try...catch
    public static void test() throws NullPointerException,ArrayIndexOutOfBoundsException {
        String str = null;
        System.out.println(str.length());
    }
}

//执行结果
Exception in thread "main" java.lang.NullPointerException
	at errorCode.ExceptionTest.test(ExceptionTest.java:107)
	at errorCode.ExceptionTest.main(ExceptionTest.java:92)

受查异常

受查异常必须显示使用try…catch…异常处理，或者throws抛出。除了Error和RuntimeExcpetion以及其子类的其他异常都是受查异常，必须显示处理。

自定义异常类

程序开发中，一定会有一些错误是和具体的业务相关的， 这种错误JDK是不可能提供相应的异常类，此时我们就需要继承已有的异常类，产生自定义的异常类。
若需要用户强制进行异常处理，继承Exception父类-受查异常。
若不需要用户显示处理异常，继承RuntimeException父类 —— 非受查异常。

import java.util.Scanner;

public class Login {
    private static String userName = "xox";
    private static String password = "123";

    public static void main(String[] args) {
        try {
            login();
        } catch (UserError userError) {
            userError.printStackTrace();
        } catch (PasswordError passwordError) {
            passwordError.printStackTrace();
        }
    }

    public static void login() throws UserError, PasswordError {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入用户名:");
        String userName = scanner.next();
        System.out.println("请输入密码:");
        String password = scanner.next();
        if (!Login.userName.equals(userName)) {
            throw new UserError("用户名错误");
        }
        if (!Login.password.equals(password)) {
            throw new PasswordError("密码错误");
        }
        System.out.println("登陆成功");
    }
}
class UserError extends Exception {
    public UserError(String message) {
        super(message);
    }
}
class PasswordError extends Exception {
    public PasswordError(String message) {
        super(message);
    }
}

 

五、内部类

所谓的内部类，就是将类结构的定义套在另一个类的内部。
内部类-共分为以下四种：成员内部类类比成员方法，静态内部类类比静态方法，方法内部类，匿名内部类- Lambda表达式的前身。
成员方法能访问静态域不能拥有静态域(无法定义静态变量)。
静态方法能访问静态域不能访问成员域。

1.成员内部类

直接定义在类中，不加任何修饰符(static)定义的类就是成员内部类  内部类和外部类可以方便的互相访问彼此的private域。

public class Otter {
    // 心脏和发动机都属于私有内部类，对外部完全隐藏，只是在类的内部来使用
    private class Inner {

    }
}

2.内部类的使用方法/规则

a. 成员内部类的创建需要依赖外部类对象，在没有外部类对象之前，无法创建成员内部类对象的(心脏就是一个成员内部类，在没有人体的情况下，是无法直接创建心脏这个对象)

b. 内部类是一个相对独立的实体，与外部类不是is - a关系(心脏is not a人)

c. 内部类可以直接访问外部类的元素和方法(包括私有域)外部类必须通过内部类的对象来访问内部类的元素和方法(包括私有域)

d. 成员内部类对象的创建外部类的内部创建就和使用其他类没啥区别内部类名称内部类引用= new内部类();

public class Otter {
    private String msg = "outter类中的msg属性";
    // 心脏和发动机都属于私有内部类，对外部完全隐藏，只是在类的内部来使用
    private class Inner {
        private int num = 10;
        public void test() {
            // 直接访问外部类的msg属性
             System.out.println(msg);
        }
    }
    public void fun() {
        // 通过内部类对象访问内部类的私有属性
        Inner inner = new Inner();
        // 访问inner类的私有属性
        System.out.println(inner.num);
        inner.test();
    }
}
在外部类的外部创建内部类对象-内部类要对外部可见(访问权限问题)
外部类名称.内部类引用F new外部类().new内部类();
Otter.Inner inner = new Otter().new Inner();
inner.test();

e. 使用内部类可以曲线救国来实现"多继承” (了解)

class A{
    int numA = 10;
}
class B{
    int numB = 20;
}

public class E {
    class C extends A{}
    class D extends B{}

    public void test() {
        C c = new C();
        D d = new D();
        System.out.println(c.numA);
        System.out.println(d.numB);
    }

    public static void main(String[] args) {
        E e = new E();
        e.test();
    }
}
//执行结果
10
20

本节完^_^

王嘻嘻-
关注
专栏目录
Kubernetes Pod状态异常九大场景盘点
uuqaz的博客
04-12 1095
Kubernetes Pod 作为 Kubernetes 核心资源对象，不仅 Service、Controller、Workload 都是围绕它展开工作。作为最小调度单元的它，还担任着传统 IT 环境主机的职责，包含了调度，网络，存储，安全等能力。 正是因为 Pod 具有复杂的生命周期和依赖，绝大多数 Kubernetes 问题最终都会在 Pod 上表现出来。因此，我们介绍在实际工作实践中会遇到的 9 种典型场景，以及如何使用 Kubernetes 监控来处理这些场景，快速定位发现问题。 容器是用户
java+mysql库存管理信息系统
05-12
此外，Java的异常处理机制和丰富的类库为系统的稳定性和功能扩展提供了保障。 2. **MySQL数据库**：MySQL是一种流行的关系型数据库管理系统，适用于大量数据存储和快速查询。在库存管理中，通常会创建如商品表、...
Java异常例子
08-09
Java异常小示例，两种异常的展现。区分两种异常的小例子
Java 异常处理 之 实例
verejava的博客
06-04 2482
http://www.verejava.com/?id=16992994231782package com.exception2; /* 题目: 老师正在给学生上课, 突然某个学生说网络断了, 老师你来帮助处理一下 没办法，我只能去找网管 */ public class TestException3//网管类 { public static void m...
JAVA异常
最新发布
FENG的学习笔记
08-19 802
在代码里：所谓异常也是程序在编写或者运行过程中出现了出乎意料的事情。eg://运行期异常， 除数为0的异常。
java项目中经常遇到的异常
weixin_38173324的博客
05-16 575
1. java.lang.nullpointerexception 异常的解释是"程序遇上了空指针"，简单地说就是调用了未经初始化的对象或者是不存在的对象， 2. java.lang.classnotfoundexception 3. java.lang.arithmeticexception 这个异常的解释是"数学运算异常"，比如程序中出现了除以零这样的运算就会出这样的异常，
Java中常见的异常举例
QJjping的博客
05-22 2307
Java中会常出现Error异常和Exception异常。Error和Exception都是Throwable的子类 Error类一般是与虚拟机相关的问题，如系统崩溃，虚拟机错误，内存空间不足，方法调用栈溢等。对于这类错误的导致的应用程序中断，仅靠程序本身无法恢复和和预防，遇到这样的错误，建议让程序终止。 Exception类表示程序可以处理的异常，可以捕获且可能恢复。遇到这类异常，应该尽可能处理异常，使程序恢复运行，而不应该随意终止异常。 于是在我们编译的时候面对Exception可以改写代码来避免
Java笔记 —— 异常（实例详解）
一纸春秋的博客
10-18 635
Java中的异常Throwable分为三种情况 Error：严重的错误，是我们无法处理的问题，比如OOM,内存溢出问题 运行时异常RuntimeException：编译器不会检查的异常，可以处理也可以不处理。但这个异常我们通常不处理，因为运行时异常一般都是我们写的程序代码出了问题。与其抛出解决异常，不如直接把代码修改正确就行。比如数组下标越界，访问null指针，类型转换错误等。 编译时异常： 除了RuntimeException运行时异常以外的异常都是编译时异常。这种异常必须要处理，如果不处理程序就无法.
shujukusheji.rar_java 仓库_java 数据库_仓库 JAVA_数据库源码
09-20
综上所述，这个压缩包中的内容为我们提供了一个完整的Java开发的仓库管理系统，涵盖了Java编程、数据库操作、业务逻辑实现等多个IT领域的核心知识点。无论是对于初学者还是经验丰富的开发者，都有很大的学习和参考...
Java+Swing+Mysql实现仓库管理系统
06-14
8. **异常处理**: 在系统开发中，异常处理是必不可少的，它能确保程序在遇到错误时能够优雅地处理，而不是直接崩溃。例如，当数据库操作失败或用户输入无效时，需要捕获异常并给出合适的提示。 9. **多线程**: 如果...
JAVA版仓库管理系统源代码
10-07
5. **异常处理**：为了确保程序的健壮性，源代码中会有适当的异常处理机制，如try-catch语句块，确保在遇到错误时能给出合适的反馈。 6. **权限控制**：对于多用户系统，权限控制必不可少。可能采用角色权限分配，...
异常示例(Exception)
12-14
异常示例(Exception)
java 中经常遇到的异常
写自己的代码，让别人去看吧
02-11 2951
运行时异常与一般异常有何异同： 异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。 运行时异常： ArithmeticException, ArrayStoreException, BufferOverflowExcep
java 中经常遇到的异常 .
u013640989的专栏
02-12 597
运行时异常与一般异常有何异同： 异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。 运行时异常： ArithmeticException, ArrayStoreException, BufferOverflowExcep
遇到的异常
weixin_43872339的博客
01-22 154
response hasbeen ommitted 这个异常出现的场景是：当对来自页面的请求进行处理之后出现了两种的方式 resopnse.sendRidrect(); 主要是在这一步的时候没有返回。 request.getSession().forward(); @AllArgsConstructor 这是lombok中的一个注解，顺带的还有 @Builder @NoArgsConstruct...
java中常见异常
程序员资料站
09-27 816
什么是异常处理机制？ 异常处理机制能让程序在异常发生时，按照代码的预先设定的异常处理逻辑，针对性地处理异常，让程序尽最大可能恢复正常并继续执行，且保持代码的清晰。 Java中的异常可以是函数中的语句执行时引发的，也可以是程序员通过throw 语句手动抛出的，只要在Java程序中产生了异常，就会用一个对应类型的异常对象来封装异常，JRE就会试图寻找异常处理程序来处理异常。  Java中的异常分类...
java几种常遇到的异常
u012858008的博客
07-26 237
1.java.sql.SQLException: 索引中丢失  IN 或 OUT 参数     解决方案：核对SQL中属性名字个数和?个数，是否一致，是否跟数据库个数一致 2.java.lang.NoSuchMethodError: javax.servlet.jsp.JspFactory.getJspApplicationContext(Ljavax/servlet/ServletConte...
Java异常 小例子
cuihao0532的博客
12-05 523
类j20exception继承自类Exception public class j20exception extends Exception{     public static void main(String args[])   {      String str1, str2;      int i, j, result;      str1 = new String(args[0]);  
java 异常举例_java运行常见异常举例
weixin_34170139的博客
02-13 137
java运行常见异常举例下面小编为大家总结了几个JAVA中常见的RuntimeException，希望对你们有所帮助：NullPointerException：空指针异常类示例1：package com.darkmi.basic;public class Test {public static void main(String[] args) {System.out.println(toUpper...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

王嘻嘻-

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值