Java基础回滚 —— 面向对象详解

已于 2023-07-24 21:27:15 修改
阅读量250 收藏
点赞数
分类专栏： Java开发 文章标签： java Javase 面向对象
于 2023-07-22 12:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62706049/article/details/131804665
版权

前言

        最近荔枝打算再系统学习和梳理一下Java后端开发的相关知识，之前也大致了解过行业招聘要求，其实学习Java后端其实路线很多而且时间很长要求也很高，但基本上都需要从Javase开始学起，然后学J2EE、spring、SSM框架开发，学完后才能学到SpringBoot，当然了如果涉及微服务的话就再加上一个Spring Cloud。除了这些，还需要深入学习数据库比如MySQL，学习一些中间件如redis、kafka等以及各自在实际开发中的使用。在求职的时候其实有些公司对分布式有要求，所以可能还得学k8s、Docker。感觉光是理论知识的学习就需要大半年了哈哈哈，Java后端实在是太卷了。。。在这篇文章中，荔枝就着重梳理一下有关于Javase的知识吧，系统再学一遍。

文章目录

前言

一、包、类和对象

1.1 基本概念 

1.2 面向对象三大特性

1.2.1 封装性

1.2.2 继承性

1.2.3 多态性

1.3 组合和继承的区分

1.4 向上转型和向下转型

1.5 抽象类和接口

1.6 枚举类enum

1.7 内部类

二、泛型和泛型类

2.1 主要特性和用途

2.2 泛型常见使用场景

2.3 泛型类

2.4 泛型接口

2.5 泛型方法

2.6 泛型通配符

总结

一、包、类和对象

1.1 基本概念 

包

为了更好的组织类，Java提供了包机制，用以创建新的命名空间并加以区别类名的命名空间。一般可以通过package ...来声明一个包的创建，import ...来导入包。

类和对象

        Java是一门面向对象的语言，对象是类的一个实例，有着独特的属性和行为；类则是一个模板，代表着一类对象的共有特性。在使用类的时候我们需要对类进行实例化并得到一个实例化对象。每个类的内部都有构造方法，如果没有显式定义类构造方法，Java编译器会自动为类隐式定义构造方法。

//类的构造方法
class Test{
    //无参构造方法
    public Test(){
    }
    //有参构造方法
    public Test(int id){
    }

}

public class TestRun{
    //实例化对象并调用其有参构造方法
    public static void main(String[] args){
        Test test = new Test(1);
    }
}

1.2 面向对象三大特性

1.2.1 封装性

        面向对象中的封装是指将抽象函式接口的实现细节进行封装隐藏，可以是做是在外围多了一层保护膜，要访问该类的话必须要通过一个严格的接口控制，防止该类的代码和数据被外部类定义的代码随机访问。具体的封装实现是对类中的属性进行private关键字修饰，并在对外提供的方法中可能会放开对公共属性的访问和修改。

//类的构造方法
public class Test{
    //私有属性
    private String name;
    private int id;

    //对外访问接口
    public setName(name){
        this.name = name;
    }
}

1.2.2 继承性

        继承关系是面向对象中的一个最为重要的特性，通过继承和重写方法使得我们的类可以实现功能的延拓。继承的过程主要有几种：子类继承父类、子类继承接口并重写。我们首先来看看子类继承父类并重写父类方法的代码示例。

class Animal{
    int age;
    String name;
    public void setName(String name){
        this.name = name;
        System.out.println(name);
    }
    public void move(){
        System.out.println("可以移动");
    }
}
//继承示例
class Pandas extends Animal{
    public void move(){
        super.move(); // 应用super类的方法
        System.out.println("可以跑和走");
    }
    public void bark(){
        System.out.println("咆哮了");
    }
    public void myName(String name){
        super.setName(name);
        System.out.println("I want to paly with "+ name);
    }
}
public class test{
    public static void main(String args[]){
        Pandas b = new Pandas(); // Pandas 对象
        b.move(); //执行 Pandas类的方法
        b.bark();
        b.myName("花花");
    }
}

        可以看到上面的子类Pandas继承并对myName方法进行重写，同时在myName使用super()继承父类的setName方法并对重写该方法。在Java中子类使用extends关键字后会默认调用父类的非参构造器，但若是想要操作父类的有参构造器或者调用父类被重写方法和属性时必须使用super()，而关键字this可以操作当前类的方法。接着看看继承多个接口类时的代码示例：

public interface A {
    public void eat();
    public void sleep();
}
 
public interface B {
    public void show();
}
 
public class C implements A,B {
}

需要注意的是Java中的继承是不能一个子类继承多个类的，Java中支持单继承和多重继承，但是使用extends是不支持同时继承两个类的。但是，对于接口的继承和重写来说，通过implements关键字却可以实现多继承。

1.2.3 多态性

        多态性是指一个模板类通过子类继承的方式使得实例化对象有着多种表现形式。多态的使用可以消除类型之间的耦合关系，同时也使得对象的使用更加灵活。相比起继承，多态相对来说更加抽象，其实堕胎的过程就是一个向上转型的过程，即父类引用指向子类实例对象。对于子类来说，向上转型中，执行了方法重写后，如果不使用super方法的话调用的是子类自己的重写方法。

我们再用上面的例子来改写多态：

class Animal{
    int age;
    String name;
    public void setName(String name){
        this.name = name;
        System.out.println(name);
    }
    public void move(){
        System.out.println("可以移动");
    }
}
//继承示例
class Pandas extends Animal{
    public void move(){
        super.move(); // 应用super类的方法
        System.out.println("可以跑和走");
    }
    public void bark(){
        System.out.println("咆哮了");
    }
    public void myName(String name){
        super.setName(name);
        System.out.println("I want to paly with "+ name);
    }
}
public class test{
    public static void main(String args[]){
        Animal b = new Pandas(); // Pandas 对象
        b.move();//可以移动、可以跑和走
        b.bark();//会报错
    }
}

多态存在的三个必要条件：继承、重写、父类引用指向子类对象。

1.3 组合和继承的区分

组合和继承是不同的，组合指的是在一个类中使用另一个类的实例对象，是一种包括的关系；另外一种是继承重写的关系。使用组合的关系能够降低类之间的耦合性。

// Person类
class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}
// Employee类使用Person类的对象作为成员变量，实现组合关系
class Employee {
    private Person person;
    private String employeeId;

    public Employee(String name, String employeeId) {
        this.person = new Person(name);
        this.employeeId = employeeId;
    }
    public String getName() {
        return person.getName();
    }
    public String getEmployeeId() {
        return employeeId;
    }
}

1.4 向上转型和向下转型

向上转型（Upcasting）和向下转型（Downcasting）是Java中多态性的一种体现，它们用于处理对象之间的类型转换。

向上转型：

  • 向上转型是将一个子类对象转换为父类类型的过程。也就是说，将子类对象赋值给父类引用变量。
  • 向上转型是自动完成的，不需要进行显式的类型转换。
  • 向上转型发生在类的继承关系中，它允许子类对象被视为父类对象，只能访问父类中定义的成员。
  • 向上转型是安全的，因为子类对象包含了父类的所有特性。
class Animal {
    public void makeSound() {
        System.out.println("动物发出声音");
    }
}
class Dog extends Animal {
    public void makeSound() {
        System.out.println("狗发出汪汪声");
    }

    public void fetch() {
        System.out.println("狗在玩飞盘");
    }
}
public class Main {
    public static void main(String[] args) {
        // 向上转型
        Animal animal = new Dog(); 
        animal.makeSound(); // 输出："狗发出汪汪声"
        // animal.fetch(); // 编译错误，不能访问子类特有的方法
    }
}

 向下转型：

  • 向下转型是将一个父类对象转换为子类类型的过程。也就是说，将父类对象赋值给子类引用变量。
  • 向下转型需要进行显式的类型转换，因为编译器不能确定父类对象是否真的是子类对象。
  • 向下转型发生在类的继承关系中，它允许父类对象重新被视为子类对象，可以访问子类中定义的特有成员。
  • 向下转型是不安全的，如果在运行时出现了不匹配的对象类型，会导致ClassCastException异常。
class Animal {
    public void makeSound() {
        System.out.println("动物发出声音");
    }
}
class Dog extends Animal {
    public void makeSound() {
        System.out.println("狗发出汪汪声");
    }

    public void fetch() {
        System.out.println("狗在玩飞盘");
    }
}
public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog(); // 向上转型

        // 向下转型，需要进行显式的类型转换
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;
            dog.fetch(); // 输出："狗在玩飞盘"
        } else {
            System.out.println("对象不是Dog类型");
        }
    }
}

1.5 抽象类和接口

        抽象类(一般用abstract来声明)除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。介绍到这里大家是不是感觉抽象类和接口有点类似？其实二者很类似，接口也是一种抽象类型不能直接被实例化，但是相比之下抽象类只能被一个子类继承并且该子类只能继承一个抽象类；而子类却可以同时继承多个接口，这就是二者最大区别，同时抽象类中可以允许有方法体，但是接口中不被允许出现实现方法的具体功能；抽象类中的成员变量可以是各种类型的但是接口的成员变量就只能是public static final类型。

方法重写和方法重载的区别

        方法重写主要发生在子类继承父类的时候使用super对父类构造方法进行继承并对方法进行重写；而方法重载是指在一个类对象中对同一命名的构造方法有不同参数对应的处理方法体。在调用的时候主要是根据传入的参数的类型来判断不同的构造方法。

1.6 枚举类enum

        Java中为我们给出了枚举类这种特殊的类，通常表示一组常量比如像颜色的枚举、地点的枚举等等。枚举类既可以在类的外部使用，也可以在类的内部使用。enum 定义的枚举类默认继承了 java.lang.Enum 类，并实现了 java.lang.Serializable 和 java.lang.Comparable 两个接口。values(), ordinal() 和 valueOf() 方法位于 java.lang.Enum类中

  • values() 返回枚举类中所有的值。
  • ordinal()方法可以找到每个枚举常量的索引，就像数组索引一样。
  • valueOf()方法返回指定字符串值的枚举常量。
enum Color 
{ 
    RED, GREEN, BLUE; 
} 
public class MyClass { 
  public static void main(String[] args) { 
    for (Color myVar : Color.values()) {
      System.out.println(myVar);
    }
  } 
}

1.7 内部类

        Java中的内部类（Inner Class）是指一个类定义在另一个类的内部。它允许在一个类中定义另一个类，使得这两个类具有一定的关联关系。内部类的定义在外部类的大括号内，可以访问外部类的成员，包括私有成员，而外部类也可以访问内部类的成员。

内部类的分类

  • 成员内部类（Member Inner Class）：成员内部类是定义在外部类的成员位置（字段、方法）的类。它持有一个对外部类的引用，可以直接访问外部类的成员。
  • 静态内部类（Static Inner Class）：静态内部类是定义在外部类的成员位置，但使用static修饰的类。它与外部类的实例无关，可以直接访问外部类的静态成员，但不能直接访问非静态成员。
  • 局部内部类（Local Inner Class）：局部内部类是定义在方法内部的类。它只在所在方法中有效，不能有访问修饰符，也不能使用static修饰。
  • 匿名内部类（Anonymous Inner Class）：匿名内部类是没有名字的内部类，它是一种简化的内部类形式。通常在创建接口或抽象类的对象时使用，直接定义并实例化一个没有类名的内部类对象。

主要特点和用途

  • 内部类提供了更好的封装性和隐藏性，可以将相关的类组织在一起，使代码结构更加清晰。

  • 内部类可以直接访问外部类的私有成员，可以用来实现一些辅助功能。

  • 成员内部类和静态内部类可以用来实现多重继承的效果，一个类可以拥有多个内部类。

  • 局部内部类和匿名内部类通常用于简化代码，避免定义额外的类。

public class OuterClass {
    private int outerField;

    public void outerMethod() {
        System.out.println("Outer method");
    }
    // 成员内部类
    public class InnerClass {
        public void innerMethod() {
            outerField = 10; // 可以访问外部类的成员
            outerMethod();   // 可以调用外部类的方法
            System.out.println("Inner method");
        }
    }
    // 静态内部类
    public static class StaticInnerClass {
        public void staticInnerMethod() {
            System.out.println("Static inner method");
        }
    }
}

二、泛型和泛型类

        在Java中，泛型（Generics）是一种编程机制仅在编译阶段使用，允许在类、接口和方法的定义中使用类型参数，以便在使用时指定具体的类型。泛型的引入使得代码更加通用、安全和可读，同时避免了类型转换的麻烦。

2.1 主要特性和用途

  • 类型参数：使用尖括号< >来定义类型参数，可以在类、接口或方法的定义中声明泛型类型。

  • 类型安全：通过使用泛型，编译器在编译时会进行类型检查，确保只有兼容的类型被传入泛型类或方法，从而避免运行时的类型转换异常。

  • 代码复用：泛型允许编写通用的代码，可以在不同的数据类型上重复使用相同的代码逻辑。

  • 避免强制类型转换：使用泛型可以避免在代码中频繁进行强制类型转换，使代码更简洁。

2.2 泛型常见使用场景

  • 集合类：Java的集合框架中的List、Set、Map等接口和实现类都使用了泛型来定义容器中存储的元素类型，使得集合类能够在编译时进行类型检查，避免了在运行时出现类型转换异常。
  • 泛型约束：在泛型中可以使用通配符和限定来对类型进行约束，例如使用extends关键字限定
  • 泛型类型必须是某个类的子类，或者使用super关键字限定泛型类型必须是某个类的父类。泛型类继承：可以在泛型类中使用继承关系，实现一个泛型类继承另一个泛型类，以提供更多的功能和灵活性。

泛型通配符：在需要处理未知类型的情况下，可以使用通配符<?>来表示不确定的类型，从而实现更通用的代码。

2.3 泛型类

// 定义一个泛型类
class Box<T> {
    private T value;

    public Box(T value) {
        this.value = value;
    }
    public T getValue() {
        return value;
    }
}
public class Main {
    public static void main(String[] args) {
        // 创建一个存储整数的Box对象
        Box<Integer> intBox = new Box<>(10);
        int value = intBox.getValue();
        System.out.println("Value: " + value);

        // 创建一个存储字符串的Box对象
        Box<String> strBox = new Box<>("Hello, Generics!");
        String message = strBox.getValue();
        System.out.println("Message: " + message);
    }
}

如果写成如下形式实例化对象的时候传入的参数和得到的参数都是一个Object对象。

Box b = new Box();

总的来说，泛型是Java中一种强大的特性，通过类型参数化实现了通用编程，使代码更灵活、类型安全，并提高代码的可读性和复用性。

2.4 泛型接口

定义一个泛型接口 

interface IFF<T>{
    T test(T t);
}

定义一个接口实现类

class B<T> implements IFF<T>{
    @Override
    public T test(T t){
        return null;
    }
}

未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中。如果实现接口时指定接口的泛型的具体数据类型，这个类实现接口所有方法的位置都要泛型替换实际的具体数据类型

public class Testl{
    public static void main(String[]args){
        Bl<Object> bl = new Bl<Object>();
        Bl<String> b2 = new Bl<String>();
        B2 b3 = new B2();
    }
}
//未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
class B1<T> implements IFF<T>{...}

//如果实现接口时指定接口的泛型的具体数据类型,这个类实现接口所有方法的位置都要泛型替换实际的具体数据类型
class B2 implements IFF<String>{
    @overwide
    public String test(String t){
        return null;
    }
}

2.5 泛型方法

class C1<E>{
    private E e;
    
    //无返回值的泛型方法
    public <T> void test(T s){
        T t = s;
        //在类上定义的泛型，可以在普通的方法中使用,但是在静态的方法中不能使用类的泛型。
        System.out.println(this.e);
    }
    //有返回值的泛型方法
    public <T> T test1(T s){
        return s;
    }
    //可变参数类型的泛型方法
    public <T> void test2(T... strs){
        for(T s : strs){
            System.out.println(s);
        }
    }
}

需要注意的是：如果泛型方法在调用之前没有固定的数据类型，那么在调用时传入参数是什么类型，就会把泛型改成什么类型，也就是说泛型方法会在调用时确定泛型具体的数据类型。 

2.6 泛型通配符

class Dd(
    //test方法需要一个1ist集合的参数，不确定1i3t集合到底是存的数的类型是什么
    public void test(List<?> 1ist){}
    //1i3t参数的元素数据类型是c1及其子类
    public void test1(List<? extends c1> 1ist){}
    //1ist参数的元素数据类型是c1及其父类
    public void test2(List<? super C1> 1ist){}
}

总结

        在这篇文章中，荔枝主要把Java中有关类和对象、泛型和泛型类的知识梳理了一下，有些地方感觉文字讲不清楚荔枝也用简单的demo来示例辅助理解，希望能帮助到有需要的小伙伴。不知道现在复习的知识什么时候能用上，什么时候被遗忘，总之尽量保证记得清楚一点吧哈哈哈。最近荔枝确实有点懈怠了，大家不要像荔枝一样噢~~~

今朝已然成为过去，明日依然向往未来！我是小荔枝，在技术成长的路上与你相伴，码文不易，麻烦举起小爪爪点个赞吧哈哈哈~~~ 比心心♥~~~

荔枝当大佬
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 数据库操作，事务回滚
04-06
java 应用程序操作数据库实例，若出现sql异常则事务回滚。
java事务回滚
qq_38335112的博客
07-26 1185
java开发中都会使用spring事物管理，事务管理有三种，1.声明式事物管理；2.手动式事务管理；3.注解式事务管理； 这三种事务管理中手动式是会回滚事物的，当程序运行出错时会回当前事物；但是声明式和注解式则会出现运行异常时不回滚事物的情况； 引用：spring事物回滚...
java 回滚事务
qq_44773028的博客
07-04 915
js代码
Java异常回滚
小武人生
10-21 661
Java异常回滚欢迎使用Markdown编辑器所以修改点 欢迎使用Markdown编辑器 ![外部循环内部逻辑](https://img-blog.csdnimg.cn/20201021103913881.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNjY4OTk5,size_16,color_FFFFFF,t_70#pic_cent
java中事物回滚的方式
weixin_44356055的博客
02-16 1万+
1.加注解 可以在方法的最上面加上@Transactional,程序出错时注解就会自动识别进行回滚操作。 @Transactional(rollbackFor = Exception.class) 如图所示: 2.调方法 可以加在你觉得出错需要回滚到代码段后面,虽然本人不知道原理,但是还的确很好用。 TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); 如图所示: 注意:两种物理回滚的方式使用其中之一即可,根据业
spring-mybatis-spring-1.3.0.zip_Java编程_Java_
08-10
《Spring与MyBatis整合详解——基于spring-mybatis-spring-1.3.0.zip》 在Java编程领域，Spring框架以其强大的依赖注入、AOP（面向切面编程）和容器管理能力，以及对各种技术的无缝集成，成为了开发者首选的开发...
Reservations:使用SQL来管理Derby数据库的Java程序。 允许从预订列表和候补列表中输入和检索数据
04-17
Java作为一种广泛使用的面向对象编程语言，因其跨平台性和丰富的类库，成为开发数据库应用程序的首选。在本项目中，Java通过JDBC（Java Database Connectivity）接口与Derby数据库进行交互，实现了数据的存取功能。...
Tic-Tac-Toe-Game:JAVA中基于GUI的井字游戏，采用单人和双人玩家模式，其中包括所有主要的OOP概念
04-28
【描述】：本项目是用Java语言开发的一款井字游戏，它结合了图形用户界面(GUI)和面向对象编程(OOP)的概念，提供单人模式和双人模式供玩家选择。游戏的核心设计基于井字游戏的经典规则，允许玩家通过直观的界面进行...
经典hibernate配置详解
07-26
Hibernate提供了一种面向对象的查询语言——HQL（Hibernate Query Language），类似于SQL，但操作的是对象而不是表格。例如，获取所有用户： ```hql SELECT u FROM User u; ``` **五、Caching缓存机制** 为了提高...
MonitorRemoteManagement
03-15
《远程监控管理技术详解——基于Java的实现》 在当今的信息化时代，远程监控管理已经成为企业运维中的重要一环。"MonitorRemoteManagement"项目恰好聚焦于此，它利用Java这一强大的编程语言，为用户提供了一套完整...
oracle 在java中的事务处理和异常回滚。
03-28
oracle 在java中的事务处理和异常回滚。 里面的类直接运行，需要把oracle的数据库连接改改就ok、
Java实战：Spring Boot 回滚操作
最新发布
oandy0的博客
03-10 1967
本文将详细介绍如何在 Spring Boot 应用程序中实现各种回滚操作。我们将深入探讨 Spring Boot 的事务管理和数据库回滚机制，以及如何使用 Java 编程语言中的异常处理和自定义逻辑来执行回滚操作。
JAVA异常与事物回滚探究
HAPP NEW JAVA
03-26 2821
spring 事务注解 默认遇到throw new RuntimeException("...");会回滚 需要捕获的throw new Exception("...");不会回滚 // 指定回滚 @Transactional(rollbackFor=Exception.class)     public void methodName() {        // 不会回滚
【Java事务提交与回滚（rollback，setAutoCommit，commit）Transaction详解】
m0_49762804的博客
06-30 4504
【Java事务提交与回滚（rollback，setAutoCommit，commit）Transaction详解，事务批量处理】
2018-03-31-java-jdbc-mysql的只进结果集ResultSet能够回滚
小肥的胖
03-31 613
使用mysql数据库的连接，使用只进结果集，在后面调用beforeFirst()方法，让指针回到第一条数据之前。 设想应该是报错，结果没有报错。 package test.use; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import ja...
【Java当中让事务回滚】
学无止境
03-10 6319
【Java当中让事务回滚】
大聪明教你学Java | Spring Boot 事务回滚
热门推荐
不肯过江东丶
01-04 1万+
我们开发系统的时候经常会遇到一些关于交易的需求，交易的过程大多数都比较繁琐（会包括修改库存、修改余额、记录交易账单等等步骤），这时候我们就不得不考虑其中的潜在风险了，比如我们在交易的过程中修改了库存（库存 -1），接下来需要进行支付操作，但是此时系统突然宕机或者网络突然中断，这也就导致我们无法完成整个交易流程，虽然用户还没付钱，但是我们的库存变少了（商家肯定就不高兴了????），所以我们就需要用到事务回滚来解决上述的问题。
JAVA事务回滚
qq_53279476的博客
10-04 2949
当一个租赁系统在租房服务时我们会判断用户的账户金额是否够支付本次的房费，如果钱够则扣款，在订单表插入一条本次业务相关的数据，这时候如果在订单表插入出现了异常，但是钱已经扣款成功了，这样的情况就可以加入事务回滚。 事务回滚将本次的操作都使用同一个Connection进行操作，于是加入了ThreadLocal存放Connection 在获取Connection时先看一下当前ThreadLocal是否存放有Connection，如果有则直接从里面获取，没有的话就创...
java 事件回滚_java – 抛出异常后回滚事务
weixin_39895167的博客
02-13 778
当我在服务方法中抛出异常时,我预计服务上的事务注释将回滚保存操作,但它不起作用.这是我的服务：@Service@Transactional(value = "transactionManager", rollbackFor = Exception.class)public class OrderServiceImp implements OrderService {@Autowiredprivat...
java如何回滚
05-30
Java中可以使用JDBC事务和Spring事务两种方式实现回滚。下面分别介绍这两种方式的回滚实现方法。 1. JDBC事务回滚 使用JDBC事务回滚需要以下步骤： - 调用Connection对象的setAutoCommit(false)方法来关闭自动...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值