【Java知识点系列】：代码块

已于 2022-03-05 16:21:19 修改
阅读量579 收藏 1
点赞数 3
分类专栏： JavaSE 文章标签： java 开发语言
于 2022-03-05 15:54:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Baridhu/article/details/123295979
版权

⭐️代码块⭐️

🍀 基本介绍

代码化块又称为初始化块,属于类中的成员[即是类的一部分]，类似于方法，将逻辑语句封装在方法体中，通过{}包围起来。

但和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显式调用，而是加载类时，或创建对象时隐式调用。

🍀 基本语法

[修饰符]{
代码
};

⚡️说明注意:

  1. 修饰符可选，要写的话，也只能写static
  2. 代码块分为两类，使用static修饰的叫静态代码块，没有static修饰的,叫普通代码块/非静态代码块。
  3. 逻辑语句可以为任何逻辑语句(输入、输出、方法调用、循环、判断等)
  4. ;号可以写上，也可以省略。

🍀代码块的好处和案例演示

  1. 相当于另外一种形式的构造器(对构造器的补充机制)，可以做初始化的操作
  2. 场景:如果多个构造器中都有重复的语句，可以抽取到初始化块中，提高代码的重用性

⚡️代码块的快速入门

public class CodeBlock01 {
    public static void main(String[] args) {
        new Movie("你好，李焕英！");
        System.out.println("===============");
        Movie movie2 = new Movie("唐探 3", 100,"陈思诚");
    }
}
class Movie{
    private String name;
    private double price;
    private String director;

    //三个构造器==》重载
    //解读
    //(1) 下面的三个构造器都有相同的语句
    //(2) 这样代码看起来比较冗余
    //(3) 这时我们可以把相同的语句，放入到一个代码块中，即可
    //(4) 这样当我们不管调用哪个构造器，创建对象，都会先调用代码块的内容
    //(5) 代码块调用的顺序优先于构造器...
    {
        System.out.println("电影屏幕打开...");
        System.out.println("广告开始...");
        System.out.println("电影正是开始...");
    }
    public Movie(String name){
        System.out.println("Movie(String name)被调用");
        this.name=name;
    }

    public Movie(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public Movie(String name, double price, String director) {
        System.out.println("Movie(String name, double price, String director)——)");
        this.name = name;
        this.price = price;
        this.director = director;
    }
}

⚡️运行结果：

电影屏幕打开...
广告开始...
电影正是开始...
Movie(String name)被调用
===============
电影屏幕打开...
广告开始...
电影正是开始...
Movie(String name, double price, String director)——)

🍀 代码块使用注意事项和细节讨论

⚡️细节一: static代码块也叫静态代码块，作用就是对类进行初始化，而且它随着类的加载而执行，并且只会执行一次。如果是普通代码块，每创建一个对象，就执行。

⚡️案例演示:
🚀static 代码块是在类加载时执行的，而且只会执行一次

public class CodeBlockDetail01 {
    public static void main(String[] args) {
        DD dd = new DD();
        DD dd1 = new DD();
    }
}
class DD {
    //静态代码块
    static {
        System.out.println("DD 的静态代码 1 被执行...");//
    }
}

DD 的静态代码 1 被执行...

⚡️细节二: 类什么时候被加载[重要!要背!]

  • 创建对象实例时(new)
  • 创建子类对象实例,父类也会被加载
  • 使用类的静态成员时(静态属性，静态方法)

⚡️案例演示:
🚀1.创建对象实例时(new)

public class CodeBlockDetail01 {
    public static void main(String[] args) {
        //类被加载的情况举例
        //1. 创建对象实例时(new)
        AA aa = new AA();
    }
}
class AA{
    //静态代码块
    static{
        System.out.println("AA的静态代码块被执行...");
    }
}

AA的静态代码块被执行...

🚀2.创建子类对象实例,父类也会被加载，而且，父类先被加载，子类后被加载

public class CodeBlockDetail01 {
    public static void main(String[] args) {
        //类被加载的情况举例
        //1. 创建对象实例时(new)
        //AA aa = new AA();
        //2. 创建子类对象实例，父类也会被加载, 而且，父类先被加载，子类后被加载
        AA aa2 = new AA();
    }
}
class BB {
    //静态代码块
    static{
        System.out.println("BB的静态代码块被执行...");
    }
}
class AA extends BB{
    //静态代码块
    static{
        System.out.println("AA的静态代码块被执行...");
    }
}

BB的静态代码块被执行...
AA的静态代码块被执行...

🚀3.使用类的静态成员时(静态属性，静态方法)

public class CodeBlockDetail01 {
    public static void main(String[] args) {
        //类被加载的情况举例
        //1. 创建对象实例时(new)
        //AA aa = new AA();
        //2. 创建子类对象实例，父类也会被加载, 而且，父类先被加载，子类后被加载
        //AA aa2 = new AA();
        //3. 使用类的静态成员时(静态属性，静态方法)
        System.out.println(Cat.n1);
    }
}
class Cat{
    public static int n1 = 999;//静态属性

    //静态代码块
    static {
        System.out.println("Cat 的静态代码 1 被执行...");//
    }
}

Cat 的静态代码 1 被执行...
999

静态代码块的优先级大于静态变量

拓展：大家思考一个问题：如果Cat有一个父类Animal，当Cat的静态变量n1被调用时，Animal类有没有被加载？

public class CodeBlockDetail01 {
    public static void main(String[] args) {
        System.out.print(Cat.n1);
    }
}
class Animal {
    //静态代码块
    static {
        System.out.println("Animal 的静态代码 1 被执行...");//
    }
}
class Cat extends Animal {
    public static int n1 = 999;//静态属性
    //静态代码块
    static {
        System.out.println("Cat 的静态代码 1 被执行...");//
    }
}

答案：会
可以看一下运行结果！

Animal 的静态代码 1 被执行...
Cat 的静态代码 1 被执行...
999

⚡️细节三: 普通的代码块，在创建对象实例时，会被隐式的调用。被创建一次，就会调用一次。如果只是使用类的静态成员时，普通代码块并不会执行。

⚡️案例演示:
🚀普通的代码块，在创建对象实例时，会被隐式的调用。被创建一次，就会调用一次。

public class CodeBlockDetail01 {
    public static void main(String[] args) {
        //普通的代码块，在创建对象实例时，会被隐式的调用。
        //被创建一次，就会调用一次。
        DD dd = new DD();
        DD dd1 = new DD();
    }
}
class DD {
    //静态代码块
    static {
        System.out.println("DD 的静态代码 1 被执行...");//
    }
    //普通代码块, 在 new 对象时，被调用，而且是每创建一个对象，就调用一次
    //可以这样简单的，理解 普通代码块是构造器的补充
    {
        System.out.println("DD 的普通代码块...");
    }
}

DD 的静态代码 1 被执行...
DD 的普通代码块...
DD 的普通代码块...

🚀如果只是使用类的静态成员时，普通代码块并不会执行

public class CodeBlockDetail01 {
    public static void main(String[] args) {
        // 如果只是使用类的静态成员时，普通代码块并不会执行
        System.out.println(DD.n1);//8888, 静态模块块一定会执行
    }
}
class DD {
    public static int n1 = 8888;//静态属性
    //静态代码块
    static {
        System.out.println("DD 的静态代码 1 被执行...");//
    }
    //普通代码块, 在 new 对象时，被调用，而且是每创建一个对象，就调用一次
    //和类加载没有关系，可以这样简单的，理解 普通代码块是构造器的补充
    {
        System.out.println("DD 的普通代码块...");
    }
}

DD 的静态代码 1 被执行...
8888

⚡️小结:
1. static代码块是类加载时，执行,只会执行一次
2. 普通代码块是在创建对象时调用的，创建一次，调用一次
3. 类加载的3种情况，需要记住(细节二)

⚡️细节四: 创建一个对象时，在一个类调用顺序是:(重点，难点);

  • 调用静态代码块和静态属性初始化(注意:静态代码块和静态属性初始化调用的优先级一样,如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用)-见案例演示1
  • 调用普通代码块和普通属性的初始化(注意:普通代码块和普通属性初始化调用的优先级一样,如果有多个普通代码块和多个普通属性初始化,则按定义顺序调用)见案例演示2
  • 调用构造方法（构造器的优先级是最低的)-见案例演示3.

⚡️案例演示:
🚀1. 调用静态代码块和静态属性初始化

代码一：

public class CodeBlockDetail02 {
    public static void main(String[] args) {
        A a = new A();
    }
}
class A{
    //静态属性初始值
    private static int n1 = getN1();

    static {//静态属性代码块

        System.out.println("A 静态代码块01");
    }

    public static int getN1(){
        System.out.println("getN1被调用");
        return 100;
    }
}

☀️运行结果：

getN1被调用
A 静态代码块01

代码二（将静态方法和静态属性换个位置）：

public class CodeBlockDetail02 {
    public static void main(String[] args) {
        A a = new A();
    }
}
class A{
    static {//静态属性代码块
        System.out.println("A 静态代码块01");
    }

    //静态属性初始值
    private static int n1 = getN1();

    public static int getN1(){
        System.out.println("getN1被调用");
        return 100;
    }
}

☀️运行结果：

A 静态代码块01
getN1被调用

可以看到两段代码的运行结果是顺序不一样的

代码一：
getN1被调用
A 静态代码块01
代码二：
A 静态代码块01
getN1被调用

⚡️说明：
静态代码块和静态属性初始化调用的优先级一样,如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用

⚡️案例演示:
🚀2. 调用普通代码块和普通属性的初始化

代码一：

public class CodeBlockDetail02 {
    public static void main(String[] args) {
        A a = new A();
    }
}
class A {
    { //普通代码块
        System.out.println("A 普通代码块 01");
    }
    private int n2 = getN2();//普通属性的初始化
    static { //静态代码块
        System.out.println("A 静态代码块 01");
    }
    //静态属性的初始化
    private static int n1 = getN1();
    public static int getN1() {
        System.out.println("getN1 被调用...");
        return 100;
    }
    public int getN2() { //普通方法/非静态方法
        System.out.println("getN2 被调用...");
        return 200;
    }
}

☀️运行结果：：

A 静态代码块 01
getN1 被调用...
A 普通代码块 01
getN2 被调用...

代码二（调换普通代码块和普通属性的顺序）：

public class CodeBlockDetail02 {
    public static void main(String[] args) {
        A a = new A();
    }
}
class A {
    private int n2 = getN2();//普通属性的初始化
    
    { //普通代码块
        System.out.println("A 普通代码块 01");
    }
    
    static { //静态代码块
        System.out.println("A 静态代码块 01");
    }
    
    //静态属性的初始化
    private static int n1 = getN1();
    public static int getN1() {
        System.out.println("getN1 被调用...");
        return 100;
    }
    public int getN2() { //普通方法/非静态方法
        System.out.println("getN2 被调用...");
        return 200;
    }
}

☀️运行结果：

A 静态代码块 01
getN1 被调用...
getN2 被调用...
A 普通代码块 01

⚡️说明：
普通代码块和普通属性初始化调用的优先级一样,如果有多个普通代码块和多个普通属性初始化,则按定义顺序调用

⚡️案例演示:
调用构造方法

public class CodeBlockDetail02 {
    public static void main(String[] args) {
        A a = new A();
    }
}
class A {
    { //普通代码块
        System.out.println("A 普通代码块 01");
    }
    private int n2 = getN2();//普通属性的初始化
    static { //静态代码块
        System.out.println("A 静态代码块 01");
    }
    //静态属性的初始化
    private static int n1 = getN1();
    public static int getN1() {
        System.out.println("getN1 被调用...");
        return 100;
    }
    public int getN2() { //普通方法/非静态方法
        System.out.println("getN2 被调用...");
        return 200;
    }
    //无参构造器
    public A() {
        System.out.println("A() 构造器被调用");
    }
}

☀️运行结果：

A 静态代码块 01
getN1 被调用...
A 普通代码块 01
getN2 被调用...
A() 构造器被调用

⭐️注意⭐️

静态相关的代码块，属性初始化，在类加载时，就执行完毕，因此是优先于构造器和普通代码块执行的

上面说的细节四一定要理解，要弄懂，要把顺序搞清楚，这是非常重要的！

⚡️细节五: 构造器的最前面其实隐含了super()和调用普通代码块

class A {
	public A( /构造器
		//这里有隐藏的执行要求
		//(1) super)://这个知识点,在前面讲解继承的时候总结过
		//(2)调用普通代码块的
		System.out.println("ok");
	}	
}

⚡️案例演示:

public class CodeBlockDetail03 {
    public static void main(String[] args) {
        new BBB();//(1)AAA 的普通代码块(2)AAA() 构造器被调用(3)BBB 的普通代码块(4)BBB() 构造器被调用
    }
}
class AAA { //父类 Object
    {
        System.out.println("AAA 的普通代码块");
    }
    public AAA() {
    //(1)super()
    //(2)调用本类的普通代码块
        System.out.println("AAA() 构造器被调用....");
    }
}
class BBB extends AAA {
    {
        System.out.println("BBB 的普通代码块...");
    }
    public BBB() {
    //(1)super()
    //(2)调用本类的普通代码块
        System.out.println("BBB() 构造器被调用....");
    }
}

☀️运行结果：

AAA 的普通代码块
AAA() 构造器被调用....
BBB 的普通代码块...
BBB() 构造器被调用....

⭐️总结⭐️

(父静>子静)>(父普>父构)>(子普>子构)

接下来是最为重量级的选手，大家打起精神来哦！
⚡️细节六: 我们看一下创建一个子类对象时(继承关系)，他们的静态代码块，静态属性初始化，普通代码块，普通属性初始化，构造方法的调用顺序如下:

①父类的静态代码块和静态属性初始化(优先级一样，按定义顺序执行)
②子类的静态代码块和静态属性初始化(优先级一样，按定义顺序执行)
③父类的普通代码块和普通属性初始化(优先级一样,按定义顺序执行)
④父类的构造方法
⑤子类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行
⑥子类的构造方法

☀️注意：面试可能会问到这样的问题。
⚡️细节七：静态代码块只能直接调用静态成员(静态属性和静态方法)，普通代码块可以调
用任意成员。

⚡️案例演示:

class C02 {
    private int n1 = 100;
    private static int n2 = 200;

    private void m1() {
    }

    private static void m2() {
    }

    static {
        //静态代码块，只能调用静态成员
        //System.out.println(n1);错误
        System.out.println(n2);//ok
        //m1();//错误
        m2();
    }

    {
        //普通代码块，可以使用任意成员
        System.out.println(n1);
        System.out.println(n2);//ok
        m1();
        m2();
    }
}

学习这些知识虽然比较麻烦,但是将来我们工作以后就会相对轻松了。

🍀练习题

⚡️T1:
下面的代码输出什么？

class Person {
    public static int total;//静态变量
    static {//静态代码块
        total = 100;
        System.out.println("in static block!");
    }
}
public class Test {
    public static void main(String[] args) {
        System.out.println("total = "+ Person.total); 
        System.out.println("total = "+ Person.total); 
    }
}

☀️答案：

in static block!
total = 100
total = 100

⚡️T2:
重点题：下面的代码输出什么？

public class Exercise{
    //主方法
    public static void main(String str[])
    {
        Test a=new Test();//无参构造器
    }
}
class Sample
{
    Sample(String s)
    {
        System.out.println(s);
    }
    Sample()
    {
        System.out.println("Sample 默认构造函数被调用");
    }
}
    //====
class Test{
    Sample sam1=new Sample("sam1 成员初始化");//
    static Sample sam=new Sample("静态成员 sam 初始化 ");//
    static{
        System.out.println("static 块执行");//
        if(sam==null)System.out.println("sam is null");
    }
    Test()//构造器
    {
        System.out.println("Test 默认构造函数被调用");//
    }
}

⚡️讲解：
① 在主方法中，创建一个Test对象时会先进行类的加载

//主方法
    public static void main(String str[])
    {
        Test a=new Test();//无参构造器
    }

我们可以看到在Test类中首先进行的就是静态成员的初始化

    static Sample sam=new Sample("静态成员 sam 初始化 ");

这时又会创建一个Sample类的对象，并且调用有参构造器 Sample(String s)

Sample(String s)
    {
        System.out.println(s);
    }

所以首先输出的是：静态成员 sam 初始化
②静态属性初始化完以后就是进行静态代码块的初始化

static{
        System.out.println("static 块执行");//
        if(sam==null)System.out.println("sam is null");
    }

这是会输出：static 块执行,由于sam已经不为空了，所以不会输出sam is null；

③加载完有关静态的以后会加载构造器Test()

 Test()//构造器
    {
        System.out.println("Test 默认构造函数被调用");
    }

由于在构造器中隐含有super()和普通代码块或普通属性初始化的调用，所以会先调用普通属性初始化：

 Sample sam1=new Sample("sam1 成员初始化");

这时就会输出语句：sam1 成员初始化
最后再输出语句：Test 默认构造函数被调用

☀️运行结果：

静态成员 sam 初始化 
static 块执行
sam1 成员初始化
Test 默认构造函数被调用
Baridhu
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
你必须掌握的20个python代码，短小精悍，用处无穷
cainiao_python的博客
03-03 2958
当今python编程语言的潮流已经成为不可阻挡的趋势，python以其较高的可读性和简洁性备受程序员的喜爱。而python编程中的一些小的技巧，运用的恰当，会让你的程序事半功倍。以下的2...
大数据必学Java基础（三十七）：代码块讲解
07-28
Java基础知识点详解：代码块讲解 Java 是一种面向对象的编程语言，它的基础知识点非常重要，在大数据处理中占据着重要的地位。今天，我们将对 Java 基础知识点进行详解，主要讲解代码块的概念、分类和执行顺序。 ...
新手学编程必会的100个代码
2201_75735270的博客
01-11 4万+
我记得刚开始接触编程的时候，觉得太难了。也很好奇，写代码的那些人也太厉害了吧？全是英文的，他们的英文水平一定很好吧？他们是怎么记住这么多代码格式的？而且错了一个标点符号，整个程序都会有影响。一个程序几千行，错一个标点符号都不行这也太难了吧？带着新手的灵魂拷问，作为从业单片机编程10年的开发者，我来为大家拨开云雾。看完以后你就会明白，其实他们也没那么厉害！即便你是初中文凭，也照样能编程。对于python语言来说，要记得东西其实不多，基本就是几个常用语句加一些关键字而已。
50个JAVA常见代码大全：学完这篇从Java小白到架构师
最新发布
linzhongshu的专栏
05-06 647
Java，作为一门流行多年的编程语言，始终占据着软件开发领域的重要位置。无论是初学者还是经验丰富的程序员，掌握Java中常见的代码和概念都是至关重要的。
cmd炫酷代码大全
热门推荐
一个无聊的程序猿
08-04 17万+
事先准备: 新建一个txt，后缀名改成cmd（或bat）里面写代码即可 声明: 文章目录cmd炫酷代码大全1.循环类1.1.黑客王国1.2.命令tree1.3.我是这条街，这条街，最靓的仔1.4.数字点阵1.5.数字王国加强版2.其他类2.1.观看星球大战完结 cmd炫酷代码大全 1.循环类 1.1.黑客王国 color a echo off :123 echo 0101010010100101010101010101010101010101010101010101001010101 echo 10101
C语言经典游戏代码大全（珍藏版）
C214574728的博客
02-17 6万+
发现很多朋友都想要一些小项目来练手，却找不到从哪里寻找，给大家整理了游戏项目开发源代码汇总。
HTML 网页特殊符号代码大全
青颜的天空的博客
07-09 4万+
HTML网页特殊符号代码大全 在网页设计中，我们有时需要把以下两种字符显示在页面上： HTML的保留字符。 无法通过键盘输入但能表达某种特殊含义的字符。 直接使用往往是无法显示的，这时就必须使用它们对应的实体名称或实体数字才能显示（在大多数浏览器中默认的字符集为ISO-8859-1）。下面做了整理，以备速查（注意：代码对大小写敏感）。 1、特色类 字符 实体名称 实体数字 描述 © © © 版权标志 | 竖线，常用作菜单或导航中的分隔符
java 代码块与静态代码块加载顺序
08-29
本文将详细介绍 Java 代码块与静态代码块加载顺序的相关知识点，并提供实例代码来帮助读者更好地理解。 一、Java 代码块 Java 代码块是指在类中使用大括号 `{}` 包围的代码块，这些代码块可以出现在类的任何位置，...
JAVA知识点复习模板.doc
11-24
JAVA知识点复习模板.doc 本文档提供了 JAVA 知识点复习模板，涵盖了 JAVA 的基础知识点，包括数据类型、字符串操作、异常处理、 Servlet 生命周期、集合框架、逻辑运算符、Map 接口实现等。 一、数据类型 JAVA ...
JAVA核心知识点整理.zip
11-18
以下是基于这个描述可能涵盖的一些关键Java知识点的详细解释： 1. **基础语法**：Java的基础包括变量、数据类型、运算符、流程控制（如if-else，switch，for，while等）、方法定义和调用、类和对象的概念。 2. **...
JAVA核心知识点整理.docx
06-10
JAVA核心知识点整理 JAVA 是一种流行的编程语言，广泛应用于 Android 应用开发、Web开发、企业软件开发等领域。随着技术的发展，JAVA 的知识点也在不断增加和更新。本文将从 JVM、线程、JVM 内存区域、垃圾回收、...
【Java】代码块（这可能是你看过的最全的代码块解析了）
xiaoliii0401的博客
07-17 741
适合初学Java或学后复习者观看，七大条注意事项非常详细，重点已突出标记，学过的人来看也能学到新的东西。
Java中的代码块
林二月的博客
07-07 407
本文详细解释了代码块的概念与使用，并深入解释了创建一个对象时的底层流程分析，非常非常重要，希望小伙伴们看后能有所收获！最后，如果本文有什么错漏的地方，欢迎大家批评指正！一起加油！！我们下一篇博文见吧！
Java学习 --- 代码块
qq_46093575的博客
09-21 524
6、创建一个子类时(继承关系),他们的静态代码块，静态属性初始化普通代码块,普通属性初始化,构造方法的调用顺序如下:①、父类的静态代码块和静态属性(优先级一样,按定义顺序执行)②、子类的静态代码块和静态属性(优先级一样，按定义顺序执行)③、父类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)④、父类的构造方法⑤、子类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)⑥、子类的构造方法。②、代码块分两类，使用static修饰的叫静态代码块，没有static修饰的叫普通代码块/非静态代码块。
代码块与静态代码块的使用
qq_45399410的博客
05-24 811
代码块又称为初始化块，属于类中的成员【即 是类的一部分】，类似于类的方法，将逻辑语句封装在方法体中，通过{}包围起来。但和方法不同，代码块没有方法名，没有返回值，没有参数，只有方法体，而且不用通过对象或类显式调用，而是加载类时，或创建类时隐式调用。Read read = new Read("小红");Read read1 = new Read("小明");System.out.println("阅读时间到！");System.out.println(name + "正在看书")
代码块的详细说明
qq_42237698的博客
01-07 4643
1、代码块：在类中或者方法中，使用{}括起来的一段代码，就称它是代码块。 代码块分为：局部代码块、初始化代码块、静态代码块三种 2、局部代码块：直接定义在方法内的代码块；一般结合if,while ,for等关键字一起使用，表示一块代码区域 void save() { { // 代码块当中 定义的变量，我们称它是局部变量 int a = 10; System.out.p...
Java学习【知识点及代码8】
huiyan_edu的博客
04-25 245
常用API讲解 一：基本数据类型包装类 1.1如何完成以下需求： 需求1：我有一个数据，请问如何判断是否是int范围内的呢? int范围 -2^31 ~ 2^31-1 package day8.edu1_integer; //需求1：我有一个数据，请问如何判断是否是int范围内的呢? // int范围 -2^31 ~ 2^31-1 //
C语言代码块
weiwei266的博客
10-26 1万+
求某某范围内的闰年 #include<stdio.h> main() {

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值