狂神说Java基础课学习记录（三）

原创 已于 2025-03-07 18:07:07 修改 · 1k 阅读 · 30 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #学习 #开发语言

于 2025-03-01 08:00:00 首次发布

学习课程来源：【狂神说Java】Java零基础学习视频通俗易懂_哔哩哔哩_bilibili

注释

注释并不会被执行。

Java中的注释：单行注释、多行注释、文档注释。

public class Hello {
    public static void main(String[] args){
        //单行注释 //
        //这是单行注释，可以注释一行文字
        //输出一个Hello,World!
        System.out.println("Hello,World!");

        //多行注释 /*  */
        /*
        这是多行注释，可以注释一段文字
        */

        //文档注释 /**  */
        /**
         *这是文档注释
         *@Description HelloWorld
         *@Author Java
         */
    }
}

标识符和关键字

标识符

关键字：

abstractassertbooleanbreakbyte
casecatchcharclassconst
continuedefaultdodoubleelse
enumextendsfinalfinallyfloat
forgotoifimplementsimport
instanceofintinterfacelongnative
newpackageprivateprotectedpublic
recordreturnstrictfpshortstatic
superswitchsynchronizedthisthrow
throwstransienttryvoidvolatile
while

Java所有的组成部分都需要名字。

类名、变量名以及方法名都被称为标识符。

标识符注意点

所有的标识符都应该以字母(A-Z或者a-z)，美元符号($)，或者下划线(_)开始。

首字符之后可以是字母(A-Z或者a-z)，美元符号($)，下划线(_)或者数字的任何字符组合。

不能使用关键字作为变量名或方法名。

Java是强类型语言，标识符大小写敏感。

可以使用中文命名，但是不建议。

数据类型

强类型语言：要求变量的使用严格符合规定，所有变量要先定义后使用。安全性高，速度慢。

弱类型语言

Java数据类型：基本类型(primitive type)、引用类型(reference type)

Java数据类型 
public class Demo02 {
    public static void main(String[] args) {
        String a = "hello";
        int num = 10;
        System.out.println(a);
        System.out.println(num);

        //八大基本数据类型
        //整数
        int num1 = 10;  //最常用
        byte num2 = 20;
        short num3 = 30;
        long num4 = 30L;  //Long类型要在数字后面加L

        //浮点数：小数
        float num5 = 50.1F;  //float类型要在数字后面加F
        double num6 = 3.1415926;

        //字符
        char name = 'A';

        //字符串 String不是关键字，而是类
        String namea = "名字";

        //布尔值 是非
        boolean flag = true;
        boolean flag1 = false;
    }
}

位(bit)：计算机内部数据存储的最小单位。

字节(byte)：计算机中数据处理的基本单位。习惯上用大写B表示。

1B(字节) = 8bit(位)，1024B = 1KB，1024KB = 1M，1024M = 1G

字符：计算机中使用的字母、数字、字和符号。

32位的操作系统只可以用32位的CPU，64位的操作系统可以用32位的CPU，也可以用64位的CPU。

数据类型扩展

最好完全避免使用浮点数进行比较

所有的字符本质还是数字

Less is More，代码要精简易读

public class Demo03 {
    public static void main(String[] args) {
        //整数扩展：进制 二进制0b  十进制  八进制0  十六进制0x
        int i = 10;
        int i2 = 010;  //八进制0
        int i3 = 0x10;  //十六进制0x 0-9 A-F
        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);

        System.out.println("----------------------------------");
        //--------------------------------
        //浮点数扩展：银行业务怎么表示 BigDecimal数学工具类
        //float 有限 离散 舍入误差 大约 接近但不等于
        //double
        //最好完全避免使用浮点数进行比较
        //最好完全避免使用浮点数进行比较
        //最好完全避免使用浮点数进行比较
        float f = 0.1f;  //0.1
        double d = 1.0/10;  //0.1
        System.out.println(f);
        System.out.println(d);
        System.out.println(f==d);  //false

        float d1 = 2324444323232f;
        float d2 = d1 + 1;
        System.out.println(d1==d2);  //true

        System.out.println("----------------------------------");
        //--------------------------------
        //字符扩展：所有的字符本质还是数字
        //编码 Unicode 2字节 65535个字符 97对应a，65对应A
        //u0000 iFFFF
        char c1 = 'a';
        char c2 = '中';
        System.out.println(c1);
        System.out.println((int)c1);  //强制转换
        System.out.println(c2);
        System.out.println((int)c2);  //强制转换

        char c3 = '\u0061';
        System.out.println(c3);  //a

        //转义字符 \t制表符 \n换行
        System.out.println("Hello\tWorld");
        System.out.println("Hello\nWorld");

        System.out.println("----------------------------------");
        //--------------------------------
        String sa = new String("hello world");
        String sa1 = new String("hello world");
        System.out.println(sa==sa1);  //false

        String sc = "hello world";
        String sd = "hello world";
        System.out.println(sc==sd);  //true
        //对象 从内存分析

        System.out.println("----------------------------------");
        //--------------------------------
        //布尔值扩展
        boolean flag = true;
        if (flag==true){
        }
        if (flag){  //两种方式意思一样
        }
    }
}

类型转换

Java类型转换有自动转换、强制转换

自动转换

低容量->高容量

byte,short,char->int->long->float->double

运算中，不同类型的数据先转化为同一类型，然后进行运算。

强制转换

高容量->低容量

格式：(类型)变量名

注意点

  1. 不能对布尔值进行转换
  2. 不能把对象类型转换为不相干的类型
  3. 把高容量转换到低容量时要强制转换，转换时可能存在内存溢出或精度问题
public class Demo05 {
    public static void main(String[] args) {
        int i = 128;
        //强制转换 (类型)变量名
        byte b = (byte)i;

        System.out.println(i);
        //内存溢出
        System.out.println(b);

        System.out.println("--------------");
        //精度问题
        System.out.println((int)23.7);  //23
        System.out.println((int)-45.89f);  ///-45

        System.out.println("--------------");
        char c = 'a';  //97
        //自动转换
        int d = c + 1;
        System.out.println(d);  //98
        //强制转换
        System.out.println((char)d);  //b
    }
}

扩展

当操作值比较大的数时，注意溢出问题

JDK7新特性：数字之间可以用下划线(_)分割

public class Demo06 {
    public static void main(String[] args) {
        int money = 10_0000_0000;
        System.out.println(money);

        int years = 20;
        //计算时溢出
        int total = money * years;
        System.out.println(total);  //-1474836480

        long total2 = money * years;  //计算完后是int，已经存在问题，转换后仍然有问题
        System.out.println(total2);  //-1474836480

        long total3 = money * (long)years;  //计算完后是long，没有问题
        System.out.println(total3);  //20000000000
    }
}

变量、常量、作用域

变量

变量是可以变化的量。

Java是一种强类型语言，每个变量必须声明类型。

Java变量是程序中最基本的存储单元，变量要素包括变量名，变量类型和作用域。

格式：一行可以定义多个变量，但是不建议（程序可读性）

type varName = [value][{,varName[=value]}];

注意点：

  1. 每个变量都有类型，类型可以是基本类型，也可以是引用类型。
  2. 变量名必须是合法的标识符。
  3. 变量声明是一条完整的语句，因此每一个声明必须以分号(;)结束。
public class Demo07 {
    public static void main(String[] args) {
        //int a,b,c;  //不建议，且没有初始化
        //int a1,b1,c1;  //不建议

        //程序可读性
        int a3 = 1;
        int b3 = 2;
        int c3 = 3;
        String name = "qin";
        char x = 'x';
        double pi = 3.14;
    }
}

变量的命名规范：

  1. 所有变量、方法、类名要见名知意。
  2. 类成员变量要符合首字母小写和驼峰原则，如monthSalary。
  3. 局部变量要符合首字母小写和驼峰原则。
  4. 常量要符合大写字母[和下划线]，如PI、MAX_VALUE。
  5. 类名要符合首字母大写和驼峰原则，如Man、GoodMan。
  6. 方法名要符合首字母小写和驼峰原则，如run()、runRun()。

作用域

类变量、实例变量、局部变量

public class Variable{
    static int allClicks = 0;  //类变量
    String str = "hello world";  //实例变量
    public void method(){
        int i = 0;  //局部变量
    }
}
1.类变量

类变量有static关键字，从属于类。

2.实例变量

实例变量在方法的外面，类的里面。

实例变量从属于对象，通过类来使用实例变量。

实例变量如果不自行初始化，默认值为这个变量类型的默认值。

  • 整型默认值为0
  • 浮点型默认值为0.0
  • 字符型默认值为0
  • 布尔值默认值为false
  • 除了基本类型，其余的类型默认值都为null
3.局部变量

局部变量使用之前必须声明和初始化值。

局部变量的作用范围在{}内。

public class Demo08 {
    //属性/变量

    //类变量
    static double salary = 2500;  //int自动转换为double

    //实例变量
    String name;
    int age;

    //main方法
    public static void main(String[] args) {
        //局部变量
        int i = 10;
        System.out.println(i);  //10

        //变量类型 变量名 = new Demo08();
        Demo08 demo08 = new Demo08();
        System.out.println(demo08.age);  //0
        System.out.println(demo08.name);  //null

        System.out.println(salary);  //2500.0
    }

    //其他方法
    public void add(){

    }
}

常量

常量是初始化后不能再被改变的值。

常量可以理解为一种特殊的变量，值被设定后，在程序运行过程中不允许被改变。

格式：常量有final关键字，常量名一般使用大写字母表示

final 常量名 = 值;

static、final这些修饰符不区分先后顺序

public class Demo09 {
    static final double PI = 3.14;
    final static double R = 3.2;
    
    public static void main(String[] args) {
        System.out.println(PI);
        System.out.println(R);
    }
}

运算符

算术运算符：

  • +、-、*、/
  • %（取余/模运算）
  • ++（自增）、–（自减）
public class Demo01 {
    public static void main(String[] args) {
        //二元运算符
        //Ctrl+D：复制当前行到下一行
        int a = 10;
        int b = 20;
        int c = 25;
        int d = 25;

        System.out.println(a+b);  //30
        System.out.println(a-b);  //-10
        System.out.println(a*b);  //200
        System.out.println(a/b);  //0 应该是0.5，但是是int型，所以为0
        System.out.println(a/(double)b); //0.5 强制转换为double

        //取余/模运算
        System.out.println(c % a);  //5   过程：c / a = 25 / 10 = 2 ... 5，余数为5
    }
}

public class Demo04 {
    public static void main(String[] args) {
        //一元运算符：++ 自增  -- 自减
        int a = 3;
        int b = a++;  //a++ 即 a = a + 1。执行完这行代码后，先给b赋值，再自增
        //隐藏了一段代码：a = a + 1;
        System.out.println(a);  //4 说明a++执行完的下一句a才会加1
        //隐藏了一段代码：a = a + 1;
        int c = ++a;  //执行完这行代码后，先自增，再给c赋值

        System.out.println(a);  //5
        System.out.println(b);  //3
        System.out.println(c);  //5
    }
}

赋值运算符：=

关系运算符：计算结果为布尔值，值只有true和false两种

  • >、<、>=、<=、==、!=
  • instanceof（判断一个对象是否是一个类的实例）
public class Demo03 {
    public static void main(String[] args) {
        //关系运算符返回结果为true或false
        int a = 10;
        int b = 20;
        int c = 21;

        System.out.println(a > b);  //false
        System.out.println(a < b);  //true
        System.out.println(a == b);  //false
        System.out.println(a != b);  //true
    }
}

逻辑运算符：

  • &&（与：两个变量都为true，结果才为true）
  • ||（或：两个变量有一个为true，结果就为true）
  • !（非：如果为true，则变为false；如果为false，则变为true）
public class Demo05 {
    public static void main(String[] args) {
        //逻辑运算符
        //与（and）  或（or）  非（取反）
        boolean a = true;
        boolean b = false;

        //逻辑与运算：两个变量都为true，结果才为true
        System.out.println("a && b："+ (a && b));  //false
        //逻辑或运算：两个变量有一个为true，结果就为true
        System.out.println("a || b："+ (a || b));  //true
        //逻辑非运算：如果为true，则变为false；如果为false，则变为true
        System.out.println("!(a && b)："+ !(a && b));  //true

        //短路运算
        int c = 5;
        boolean d = (c < 4) && (c++ < 4);  //c < 4的结果为false，后面不再执行，结果直接为false
        System.out.println(d);  //false
        System.out.println(c);  //5  说明没有执行c++ < 4
    }
}

位运算符：

  • &（一位一位的计算，对应位都为1才为1）
  • |（一位一位的计算，对应位都为0才为0）
  • ^（一位一位的计算，对应位相同为0，不同为1）
  • ~（一位一位的计算，每个位取反）
  • <<、>>>（了解）
public class Demo06 {
    public static void main(String[] args) {
        /*
        A = 0011 1100
        B = 0000 1101

        A & B（一位一位的计算，对应位都为1才为1）      0000 1100
        A | B（一位一位的计算，对应位都为0才为0）      0011 1101
        A ^ B（一位一位的计算，对应位相同为0，不同为1） 0011 0001
        ~B（一位一位的计算，每个位取反）              1111 0010
         */

        /*
        2 * 8 = 16  2 * 2 * 2 * 2
        << 把数字往左移几位，数字变大，相当于 * 2
        >> 把数字往右移几位，数字变小，相当于 / 2

        0000 0000  0
        0000 0001  1
        0000 0010  2
        0000 0011  3
        0000 0100  4
        0000 1000  8
        0001 0000  16
        0001 1000  24
         */
        
        System.out.println(2 << 3);  //16  2 * 2 * 2 * 2
        System.out.println(3 << 3);  //24  3 * 2 * 2 * 2
    }
}

条件运算符：x ? y:z（如果x==true，则结果为y，否则结果为z）

public class Demo08 {
    public static void main(String[] args) {
        //三元运算符
        //x ？ y : z
        //如果x==true，则结果为y，否则结果为z
        int score = 80;
        String type = score < 60 ? "不及格" : "及格";
        System.out.println(type);
    }
}

扩展赋值运算符：+=、-+、*=、/=

public class Demo07 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        a+=b;  //a = a + b
        System.out.println(a);  //30
        a-=b;  //a = a- b
        System.out.println(a);  //10

        //字符串连接符 +，String
        System.out.println(a+b);  //30
        System.out.println(""+a+b);  //String类型的1020
        System.out.println(a+b+"");  //String类型的30
    }
}

注意点：

  1. 运算结果的数据类型为参与运算的变量中最高容量的数据类型。

  2. 在java中，整数默认是int类型，小数默认是double类型。

    public class Demo02 {
    public static void main(String[] args) {
        long a = 121346756723L;
        int b = 123;
        short c = 10;
        byte d = 8;

        System.out.println(a+b+c+d);  //long
        System.out.println(b+c+d);  //int
        System.out.println(c+d);  //int
    }
}

  3. 关系运算符可以与if搭配使用。

  4. 扩展：很多运算会使用工具类来操作，如幂运算。

    public class Demo04 {
    public static void main(String[] args) {
        //幂运算 2的3次方 2*2*2 = 8
        //很多运算会使用工具类来操作
        double pow = Math.pow(2,3);
        System.out.println(pow);  //8.0
    }
}
  5. 优先级运算符简介结合性
    1[ ]、.、( )方法调用，属性获取从左向右
    2!、~、 ++、 –一元运算符从右向左
    3* 、/ 、%乘、除、取模（余数）从左向右
    4+ 、 -加减法从左向右
    5<<、 >>、 >>>左位移、右位移、无符号右移从左向右
    6< 、<= 、>、 >=、 instanceof小于、小于等于、大于、大于等于， 对象类型判断是否属于同类型从左向右
    7== 、!=2个值是否相等，2个值是否不等于。 下面有详细的解释从左向右
    8&按位与从左向右
    9^按位异或从左向右
    10|按位或从左向右
    11&&短路与从左向右
    12||短路或从左向右
    13?:条件运算符从右向左
    14=、 += 、-= 、*= 、/=、 %=、 &=、 |=、 ^=、 <、<= 、>、>= 、>>=混合赋值运算符从右向左

包机制

为了更好地组织类，Java提供了包机制，用于区别类名的命名空间。

包的本质就是文件夹。

格式：

package pkg1[. pkg2[. pkg3...]];

一般利用公司域名倒置作为包名。

为了能使用某一个包的成员，需要在Java程序中明确导入该包，使用“import”语句可以完成。格式：*表示通配符，导入这个包里的所有类

import package1[.package2.(classname|*);

《阿里巴巴开发手册》

JavaDoc

javadoc命令是用来生成自己的API文档

jdk帮助文档

使用cmd生成JavaDoc文档

格式：javadoc 参数 Java文件

/**
 * @author zhi
 * @version 1.0
 * @since 1.8
 */

public class Doc {
    String name;

    /**
     * @author zhi
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name) throws Exception{
        return name;
    }
}

步骤：

  1. 右键类->Open In->Explorer
    在这里插入图片描述

  2. 在打开的文件夹地址栏开头输入cmd(空格)->回车

  3. 输入javadoc -encoding UTF-8 -charset UTF-8 Doc.java->回车

使用IDEA生成JavaDoc文档

可参考：使用IDEA生成JavaDoc文档（IDEA2020.3.2）_idea快捷键将所有javadoc注释转为读模式-CSDN博客

【Java从入门到天黑|02】SE入门之Java基础
孙叫兽的博客
04-16 3627
Java基础
Java后端开发工程师学习笔记【狂神说Java笔记】
m0_67402970的博客
09-11 1234
深知大多数初中级Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！因此收集整理了一份《Java开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
B站【狂神说Java笔记】-网络编程
2401_83817843的博客
04-01 1018
最近我根据上述的技术体系图搜集了几十套腾讯、头条、阿里、美团等公司21年的面试题，把技术点整理成了视频（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，这里以图片的形式给大家展示一部分。最近我根据上述的技术体系图搜集了几十套腾讯、头条、阿里、美团等公司21年的面试题，把技术点整理成了视频（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，这里以图片的形式给大家展示一部分。os.write(“我接收完毕了，你可以断开了”.getBytes());
【狂神说Java】Java基础详细笔记(全)
Martin-share的博客
01-06 9847
狂神说Java之Java基础-程序运行机制-基础语法-流程控制-方法-数组-面向对象-异常
2021-03-25 狂神说Java之 JavaSE学习
fggsgnhz的博客
03-27 948
常见的DOS命令 打开CMD的方式 1、开始+系统+命令提示符 2、win + R 输入cmd 打开控制台 3、在任意文件夹下面，按住 shift +鼠标右键点击，在此处打开命令行窗口 4、资源管理器的地址栏前面加上 cmd 路径 管理员方式运行：选择以管理员运行的 方式（可以得到最高权限） 关于目录切换命令： # 盘符切换 C:\Users\XXX> D: D:\> # 常看当前目录下的所有文件 D:\> dir 驱动器 D 中的卷没有标签。 卷的序列号是 9E77-CA9C
狂神同步课学习笔记-java学习路线
01-14
狂神同步课学习笔记-java学习路线的内容涉及了Java编程语言的学习路径。Java作为一种广泛使用的编程语言，拥有跨平台、面向对象、安全性高等特点，是许多开发者的首选。学习Java需要按照一定的路线逐步深入，这份...
基于《狂神说Java》SpringCloud --学习笔记
wudidahuanggua的博客
06-21 1350
本笔记仅做学习与复习使用，不存在刻意抄袭。参考于学友菜鸟小杰子。给各位学友强烈推荐《遇见狂神说》他的整套Java学习路线使我获益匪浅！！!
狂神说SpringCloud学习笔记
qq_43161404的博客
01-09 2487
前言：B站狂神说Java中SpringBoot笔记，传送门 UP很nice，课程生动形象，欢迎支持。 一、什么是微服务 整体部署：每一个模块的变更很难不影响到其他模块，使得变更周期变得漫长，扩展需要整体扩展，而不能进行部分扩展。 就目前而言，对于微服务，业界并没有一个统一的，标准的定义。 但通常而言，微服务架构是一种架构模式，或者说是一种架构风格，它体长将单一的应用程序划分成一组小的服务，每个服务运行在其独立的自己的进程内，服务之间互相协调，互相配置，为用户提供最终价值，服务之间采用轻量级的通信机制(HT
狂神说Linux课堂笔记.pdf
03-25
综上所述，这篇狂神说Linux课堂笔记是对那些打算从事Java全栈开发者的Linux学习指南。它不仅提供了Linux的理论知识，还结合实际开发工作，指出了学习Linux的重要性及学习路径。通过这堂课的学习，开发者可以为在...
SpringCloud学习笔记-狂神说
weixin_44202871的博客
07-17 759
SpringBoot 微服务
【狂神】JAVA学习全套笔记（完整版）
03-12
内容包含： 1、JAVA SE 2、MySQL + JDBC 3、JAVA WEB 4、Mybatis 5、SSM 6、大前端 7、Vue 8、SpringBoot 9、Spring Security 10、Shiro 11、Spring Cloud 12、JVM 13、JUC 14、Git 15、Linux 16、Redis 17、ElasticSearch 18、Docker
狂神说Java--Java学习笔记(合集)
qq_41924554的博客
07-22 2779
笔记参考来源狂神说Java视频 https://www.bilibili.com/video/BV12J41137hu 本篇笔记有点长，可以根据目录定位，建议配合视频学习。 Java流程控制 用户交互Scanner 之前我们学的基本语法并没有实现程序和人的交互，Java给我们提供了一个工具类，可以获取用户的输入。 java.util.Scanner是Java5的新特征，我们通过Scanner类来获取用户的输入。 基本语法 Scanner s = new Scanner(System.in); .
【狂神说Java】Java零基础笔记（持续更新）
02年某不知名大学本科大四
11-14 781
Java中的注释有三种：具体操作代码如下： 02.标识符和关键字 关键字
Java学习笔记（笔记来源：B站UP主遇见狂神说的Java课程总结）
qq_63826709的博客
07-14 1175
目录Java基础（12节）Java基础01:注释Java基础02：标识符和关键字Java基础03：数据类型Java基础04：数据类型扩展及面试题讲解Java基础05：类型转换Java基础06：变量，常量，作用域Java基础07：基本运算符Java基础08：自增自减运算符，初识Math类Java基础09：逻辑运算符，位运算符Java基础10：三元运算符与小结Java基础11：包机制Java基础12：JavaDoc生成文档 Java中的注释有三种单行注释//多行注释/* */JavaDoc：文档注释/** */
狂神说java--java零基础笔记
最新发布
qq_70368442的博客
04-18 1194
基于B站狂神说java，加上自己的理解，整理而成的java零基础笔记，后续持续更新
Java一些基础语法
The_Ink的博客
06-30 553
Java基础语法 注释 注释并不会被执行，是给我们写代码的人看的 书写注释是一个非常好的习惯 平时写代码一定要注意规范 Java中的注释有三种： 单行注释 // 注释 多行注释 / 注释 / 文档注释 标识符 关键字 Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。 标识符的注意点 所有的标识符都应该以字母（A-Z 或者 a-z），美元符（$）、或者下划线（_）开始 首字符之后可以是字母（A-Z 或者 a-z），美元符（$）、下划
狂神说Java系列笔记，java高级技术经理面试题
m0_63174529的博客
03-06 386
(img-EspWWaoC-1709675622139)]分享一份自己整理好的Java面试手册，还有一些面试题pdf。
狂神说Java学习笔记——多线程
weixin_65098078的博客
07-19 1892
狂神说Java学习笔记——多线程
狂神说JAVA系列全面学习笔记：基础到微服务架构
资源摘要信息:"狂神说java系列笔记涵盖了Java编程语言的核心知识点，从Java基础、Javaweb技术，到Spring框架、微服务架构以及容器化技术都有详细的记录。本系列笔记对理解Java语言的原理和应用实践具有重要的参考...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值