JavaSE第七节————类和对象（上）

最新推荐文章于 2024-09-16 21:37:07 发布
最新推荐文章于 2024-09-16 21:37:07 发布
阅读量562 收藏 9
点赞数 18
分类专栏： JAVASE学习 文章标签： java 开发语言 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79418684/article/details/132666645
版权

系列文章目录

JavaSE第七节————类和对象（上）

类和对象

  1. 面向对象的初步认知
  2. 类的定义和使用
  3. 类的实例化
  4. this引用
  5. 对象的构造及初始化
  6. 封装
  7. static成员
  8. 代码块
  9. 内部类
  10. 对象的打印

文章目录

一、面向对象的初步认知

1. 什么是面向对象

Java是一门纯面向对象的语言(Object Oriented Program，简称OOP)，在面向对象的世界里，一切皆为对象。面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。用面向对象的思想来涉及程序，更符合人们对事物的认知，对于大型程序的设计、扩展以及维护都非常友好

2.面向对象与面向过程

面向过程：OOP，分析问题的解决步骤，而后用 函数 把步骤按顺序一一实现并调用即可。

面向对象：POP，把构成问题的事务分解为各种对象，而建立对象的目的不是为了完成一个一个的步骤，而是描述某个事务在解决整个问题过程中发生的行为。

例如：把大象塞进冰箱需要几步？

面向过程解析（需要三步）：

  1. 打开冰箱
  2. 把大象塞进去
  3. 关上冰箱

上述这三个步骤构成了一个过程，这个过程的目的就是把大象塞进冰箱。

面向对象解析

我们先把这件事情的两个主体找到，一个是大象，一个是冰箱。然后分别分析两个主体各自需要做什么事情。
大象（主体）：

1、走进冰箱

冰箱（主体）：

1、开门
2、关门

分析好了两个主体需要做的事情，那么把大象塞进冰箱就可以这样划分了：

  1. 冰箱执行冰箱1（开门）
  2. 然后大象执行大象1（走进冰箱）
  3. 最后冰箱执行冰箱2（关门）

通过这种方式，依然可以实现把大象塞进冰箱的操作！但是，这种方式是以主体划分的，这个主体就是我们所谓的对象，而采用这种方式编程就是我们常常听到的面向对象编程。

注意：面向过程和面相对象并不是一门语言，而是解决问题的方法，没有那个好坏之分，都有其专门的应用场景

二、类的定义和使用

类是用来对一个实体(对象)来进行描述的，主要描述该实体(对象)具有哪些属性(外观尺寸等)，哪些功能(用来干啥)，描述完成后计算机就可以识别了.

比如：洗衣机，它是一个品牌，在Java中可以将其看成是一个类别。
属性：产品品牌，型号，产品重量，外观尺寸，颜色…
功能：洗衣，烘干、定时…

在Java语言中，如何对上述的洗衣机类来进行定义呢？

1.类的定义格式（ * * ）

成员变量一共分为两种：

  1. 普通成员变量
  2. 静态成员变量

成员变量也分为两种：

  1. .普通成员方法
  2. 静态成员方法

在java中定义类时需要用到class关键字，具体语法如下

 //属性  字段   普通成员变量  ： 定义在类当中  方法外部的 变成
    // public 访问修饰限定符
    public String name;
    public int age;

    //静态成员变量 -> 不在对象当中
    public static int count = 10;


    //行为  普通的成员方法
    public void sleep() {

    }

    //静态成员方法
    public static void staticMethod() {

    }

class为定义类的关键字，ClassName为类的名字，{}中为类的主体。

类中包含的内容称为类的成员。属性主要是用来描述类的，称之为类的成员属性或者类成员变量。方法主要说明类具有哪些功能，称为类的成员方法。

  class WashMachine{
        public String brand; // 品牌
        public String type; // 型号
        public double weight; // 重量
        public double length; // 长
        public double width; // 宽
        public double height; // 高
        public String color; // 颜色
        public void washClothes(){ // 洗衣服
            System.out.println("洗衣功能");
        }
        public void dryClothes(){ // 脱水
            System.out.println("脱水功能");
        }
        public void setTime(){ // 定时
            System.out.println("定时功能");
        }
    }

注意事项

  1. 类名注意采用大驼峰定义
  2. 成员前写法统一为public，后面会详细解释
  3. 此处写的方法不带 static 关键字. 后面会详细解释

2.定义类的案例（ * * ）

定义一个狗类

狗类包含：

  1. 静态属性（变量）
    （1)名字
    （2）毛发颜色
  2. 动态属性（方法）
    （1）摇尾巴
    （2）汪汪叫
class PetDog {
        // 狗的静态属性（变量）
        public String name;//名字
        public String color;//颜色
        // 狗的动态属性（方法）
        public void barks() {
            System.out.println(name + ": 旺旺旺~~~");
        }
        public void wag() {
            System.out.println(name + ": 摇尾巴~~~");
        }
    }

定义一个学生类

学生类包含：

  1. 静态属性（变量）
    （1)姓名
    （2）性别
    （3）年龄
    （4）学分
  2. 动态属性（方法）
    （1）上课
    （2）写作业
    （3）考试
 public class Student{
        public String name;
        public String gender;
        public short age;
        public double score;
        public void DoClass(){}
        public void DoHomework(){}
        public void Exam(){}
    }

注意事项：

  1. 一般一个文件当中只定义一个类
  2. main方法所在的类一般要使用public修饰(注意：Eclipse默认会在public修饰的类中找main方法)
  3. public修饰的类必须要和文件名相同
  4. 不要轻易去修改public修饰的类的名称，如果要修改，通过开发工具修改。

通过开发工具修改类的名称

在这里插入图片描述

在这里插入图片描述

三、类的实例化

1.什么是实例化

定义了一个类，就相当于在计算机中定义了一种新的类型，与int，double类似，只不过int和double是java语言自带的内置类型，而类是用户自定义了一个新的类型，比如上述的：PetDog类和Student类。它们都是类(一种新定义的类型)有了这些自定义的类型之后，就可以使用这些类来定义实例(或者称为对象)。

用类类型创建对象的过程，称为类的实例化，在java中采用new关键字，配合类名来实例化对象

在这里插入图片描述

 static class PetDog {
        // 狗的静态属性（变量）
        public String name;//名字
        public String color;//颜色
        // 狗的动态属性（方法）
        public void barks() {
            System.out.println(name + ": 旺旺旺~~~");
        }
        public void wag() {
            System.out.println(name + ": 摇尾巴~~~");
        }
    }
    public static void  main(String[] args) {
        PetDog dog1 = new PetDog();//通过new实例化对象
        dog1.name = "旺财";
        dog1.color = "土黄";

        System.out.println(dog1.name);
        System.out.println(dog1.color);
        dog1.barks();
        dog1.wag();

        System.out.println("____________________________");
        PetDog dog2 = new PetDog();
        dog2.name = "赤丸";
        dog2.color = "黑白";

        System.out.println(dog1.name);
        System.out.println(dog1.color);
        dog2.barks();
        dog2.wag();
    }

在这里插入图片描述

注意事项：

  1. new 关键字用于创建一个对象的实例.
  2. 使用 . 来访问对象中的属性和方法.
  3. 同一个类可以创建对个实例

2.类和对象的说明

  1. 类只是一个模型一样的东西，用来对一个实体进行描述，限定了类有哪些成员.
  2. 类是一种自定义的类型，可以用来定义变量。
  3. 一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量。
  4. 做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间。
    在这里插入图片描述

四、this引用

1.为什么要有this引用？

先看一个日期类的例子:

public class Date {
    public int year;
    public int month;
    public int day;
 
    public void setDay(int y, int m, int d) {
        year = y;
        month = m;
        day = d;
    } 
    public void printDate() {
        System.out.println(year + "/" + month + "/" + day);
    } 
    public static void main(String[] args) {
// 构造三个日期类型的对象 d1 d2 d3
        Date d1 = new Date();
        Date d2 = new Date();
        Date d3 = new Date();
// 对d1，d2，d3的日期设置
        d1.setDay(2020, 9, 15);
        d2.setDay(2020, 9, 16);
    }
}

上代码定义了一个日期类，然后main方法中创建了三个对象，并通过Date类中的成员方法对对象进行设置和打印，代码整体逻辑非常简单，没有任何问题。
但是细思之下有以下两个疑问：

  1. 形参名不小心与成员变量名相同：
public void setDay(int year, int month, int day){
	year = year;
	month = month;
	day = day;
}

那函数体中到底是谁给谁赋值？成员变量给成员变量？参数给参数？参数给成员变量？成员变量参数？估计自己都搞不清楚了

  1. 三个对象都在调用setDate和printDate函数，但是这两个函数中没有任何有关对象的说明，setDate和printDate函数如何知道打印的是那个对象的数据呢?

在这里插入图片描述

2.什么是this引用

this引用指向当前对象(成员方法运行时调用该成员方法的对象)，在成员方法中所有成员变量的操作，都是通过该引用去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成

public static class Date {
        public int year;
        public int month;
        public int day;
        public void setDay(int year, int month, int day){
            this.year = year;
            this.month = month;
            this.day = day;
        }
        public void printDate(){
            System.out.println(this.year + "/" + this.month + "/" + this.day);
        }
    }
    public static void main(String[] args) {
        Date d = new Date();
        d.setDay(2020,9,15);
        d.printDate();
       }
    }

在这里插入图片描述
要尽量使用this

3. this引用的特性（ * * ）

  1. this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型
  2. this只能在"成员方法"中使用
  3. 在"成员方法"中，this只能引用当前对象，不能再引用其他对象
  4. this是“成员方法”第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法对象的引用传递给该成员方法，this负责来接收
public static class Date {
        public int year;
        public int month;
        public int day;
        public void setDay(Date this,int year, int month, int day){
            this.year = year;
            this.month = month;
            this.day = day;
        }
        public void printDate(Date this){
            System.out.println(this.year + "/" + this.month + "/" + this.day);
        }
    }
    public static void main(String[] args) {
        Date d = new Date();
        d.setDay(2020,9,15);
        d.printDate();
    }

五、对象的构造及初始化

1.如何初始化对象

通过前面知识点的学习知道，在Java方法内部定义一个局部变量时，必须要初始化，否则会编译失败
在这里插入图片描述
要让上述代码通过编译，非常简单，只需在正式使用a之前，给a设置一个初始值即可。如果是对象：

public static class Date {
        public int year;
        public int month;
        public int day;
        public void setDay(Date this,int year, int month, int day){
            this.year = year;
            this.month = month;
            this.day = day;
        }
        public void printDate(Date this){
            System.out.println(this.year + "/" + this.month + "/" + this.day);
        }
    }
public static void main(String[] args) {
	Date d = new Date();
	d.printDate();
	d.setDate(2021,6,9);
	d.printDate();
}

需要调用之前写的SetDate方法才可以将具体的日期设置到对象中。通过上述例子发现两个问题：

  1. 每次对象创建好后调用SetDate方法设置具体日期，比较麻烦，那对象该如何初始化？
  2. 局部变量必须要初始化才能使用，为什么字段声明之后没有给值依然可以使用？

补充：

成员变量：

        public String name;//引用类型
        public int month;//基本类型

成员变量在没有初始化的时候都有一个默认值
int 的默认值是 0
float 的默认值是 0.0f
double 的默认值是 0.0
引用类型的默认值是 null
Boolean的默认值是 false
char 的默认值是’\u0000’

2.构造方法（ * * * ）

概念

构造方法(也称为构造器)是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次。

  public class Date {
        public int year;
        public int month;
        public int day;
        // 构造方法：
// 名字与类名相同，没有返回值类型，设置为void也不行
// 一般情况下使用public修饰
// 在创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次
        public Date(int year, int month, int day){
            this.year = year;
            this.month = month;
            this.day = day;
            System.out.println("Date(int,int,int)方法被调用了");
        }
        public void printDate(){
            System.out.println(year + "-" + month + "-" + day);
        }
        public static void main(String[] args) {
// 此处创建了一个Date类型的对象，并没有显式调用构造方法
            Date d = new Date(2021,6,9); // 输出Date(int,int,int)方法被调用了
            d.printDate(); // 2021-6-9
        }
    }
    public class Date {
        public int year;
        public int month;
        public int day;
        // 无参构造方法
        public Date(){
            this.year = 1900;
            this.month = 1;
            this.day = 1;
        }

注意：构造方法的作用就是对对象中的成员进行初始化，并不负责给对象开辟空间。

特性

  1. 名字必须与类名相同
  2. 没有返回值类型，设置为void也不行
  3. 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次(相当于人的出生，每个人只能出生一次)
  4. 构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)
public class Date {
    public int year;
    public int month;
    public int day;
    // 无参构造方法
    public Date(){
        this.year = 1900;
        this.month = 1;
        this.day = 1;
    }
    // 带有三个参数的构造方法
    public Date(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
    public void printDate(){
        System.out.println(year + "-" + month + "-" + day);
    }
    public static void main(String[] args) {
        Date d = new Date();
        d.printDate();
    }
}

上述两个构造方法：名字相同，参数列表不同，因此构成了方法重载

  1. 如果用户没有显式定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定是无参的
public class Date {
    public int year;
    public int month;
    public int day;
    public void printDate(){
        System.out.println(year + "-" + month + "-" + day);
    }
    public static void main(String[] args) {
        Date d = new Date();
        d.printDate();
    }
}

上述Date类中，没有定义任何构造方法，编译器会默认生成一个不带参数的构造方法。
注意：一旦用户定义，编译器则不再生成。

public class Date {
    public int year;
    public int month;
    public int day;
    public Date(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
    public void printDate(){
        System.out.println(year + "-" + month + "-" + day);
    }
    public static void main(String[] args) {
// 如果编译器会生成，则生成的构造方法一定是无参的
// 则此处创建对象是可以通过编译的
// 但实际情况是：编译期报错
//原因: 实际参数列表和形式参数列表长度不同
        Date d = new Date();
        d.printDate();
    }
}

在这里插入图片描述

  1. 构造方法中，可以通过this调用其他构造方法来简化代码
public class Date {
    public int year;
    public int month;
    public int day;
    // 无参构造方法--内部给各个成员赋值初始值，该部分功能与三个参数的构造方法重复
    // 此处可以在无参构造方法中通过this调用带有三个参数的构造方法
    // 但是this(1900,1,1);必须是构造方法中第一条语句
    public Date(){
    //System.out.println(year); 注释取消掉，编译会失败
        this(1900, 1, 1);
    //this.year = 1900;
    //this.month = 1;
    //this.day = 1;
    } 
    // 带有三个参数的构造方法
    public Date(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
}

注意：
this(…)必须是构造方法中第一条语句
不能形成环

public Date(){
this(1900,1,1);
}
public Date(int year, int month, int day) {
this();
} 
/* 无参构造器调用三个参数的构造器，而三个参数构造器有调用无参的构造器，形成构造器的递归调用
编译报错：Error:(19, 12) java: 递归构造器调用
*/
  1. 绝大多数情况下使用public来修饰，特殊场景下会被private修饰(后序讲单例模式时会遇到)

3.默认初始化

为什么局部变量在使用时必须要初始化，而成员变量可以不用呢？

public static class Date {
        public int year;
        public int month;
        public int day;
        public Date(int year, int month, int day) {
// 成员变量在定义时，并没有给初始值, 为什么就可以使用呢？
            System.out.println(this.year);
            System.out.println(this.month);
            System.out.println(this.day);
        }
        public static void main(String[] args) {
// 此处a没有初始化，编译时报错：
// Error:(24, 28) java: 可能尚未初始化变量a
// int a;
// System.out.println(a);
            Date d = new Date(2021,6,9);
        }
    }

要搞清楚这个过程，就需要知道 new 关键字背后所发生的一些事情：

Date d = new Date(2021,6,9);

在程序层面只是简单的一条语句，在JVM层面需要做好多事情，下面简单介绍下：

  1. 检测对象对应的类是否加载了，如果没有加载则加载

  2. 为对象分配内存空间

  3. 处理并发安全问题
    比如：多个线程同时申请对象，JVM要保证给对象分配的空间不冲突

  4. 初始化所分配的空间
    即：对象空间被申请好之后，对象中包含的成员已经设置好了初始值，比如
    在这里插入图片描述

  5. 设置对象头信息(关于对象内存模型后面会介绍)

  6. 调用构造方法，给对象中各个成员赋值

4.就地初始化

在声明成员变量时，就直接给出了初始值

public class Date {
    public int year = 1900;
    public int month = 1;
    public int day = 1;
    public Date(){
    }
    public Date(int year, int month, int day) {
    }
    public static void main(String[] args) {
        Date d1 = new Date(2023,7,29);
        Date d2 = new Date();
    }
}

注意：代码编译完成后，编译器会将所有给成员初始化的这些语句添加到各个构造函数中

莲雾flops
关注
专栏目录
JavaSE第五节课异常和线程————小白学习之路
学习阶段，互相共勉
04-26 194
异常，线程第一章 异常1.1 异常概念代码演示1.2 异常体系**Throwable体系：****Throwable中的常用方法**：1.3 异常分类1.4 异常产生的流程第二章 异常的处理2.1抛出异常throw代码演示2.2 Objects非空判断2.3 throws处理异常的方式2.4捕获异常try...catch代码演示2.5 try-catch和throw使用区别代码演示2.6 fi...
javaSE_day15 —— 模拟会话聊天室
LIKE_0217的博客
08-04 228
模拟会话聊天室v1：代码修正v2: 控制台一对一会话v3：一个客户端和服务器多次会话v4：实现多线程的服务端v5：实现群聊v6：实现窗口v7：读写对象v8：添加登录的窗口，根据登录名称显示用户姓名 v1：代码修正 1.定义成员变量套接字 2.在构造方法中初始化 3.start方法处理读写 4.main方法创建对象，调用start方法 客户端： public class Client { private Socket socket; public Client(){ try { socket =
JavaSE第七节————类和对象（下）
2301_79418684的博客
08-14 690
类和对象 1. 面向对象的初步认知 2. 类的定义和使用 3. 类的实例化 4. this引用 5. 对象的构造及初始化 6. 封装 7. static成员 8. 代码块 9. 内部类 10. 对象的打印
JavaSE第九节————抽象类和接口（下）
2301_79418684的博客
08-16 659
抽象类和接口 1. 抽象类 2. 接口 3. Object类 4. 内部类
【JavaSE系列】第七节 —— 类和对象（2）
未央的博客哟
11-22 765
本节内容接上一小节内容，继续讲解关于Java的类和对象的有关内容。让我们继续学习本节内容，更好的了解Java的核心吧！！！
JavaSE第十节————认识String类
2301_79418684的博客
08-16 859
认识String类 1. 认识 String 类 2. 了解 String 类的基本用法 3. StringBuilder和StringBuffer 4. String类练习题
#笔记#圣思园 JavaSE 第76讲——GUI，AWT组件，布局管理器
aliuxiaohuaxixi的专栏
06-17 495
1.GUI——Graphical User Interface——图形用户界面 根据作用分类，GUI组件可分为 基本组件 和 容器 组件：又称构件，如按钮、文本框等 容器：特殊的组件，可以容纳其他组件，如窗口、对话框等。             所有容器类都是java.awt.Container的直接或间接子类 2.AWT——Abstract Window Toolkit——抽象窗口
第一阶段：狂神说——javaSE(基础)
qq_44697268的博客
07-10 629
狂神说java，学习笔记，javaSE第一阶段，打基础基础，
JavaSE基础教程——学习笔记整理（更新中）
hewenqing
01-02 459
JavaSE基础教程 1、Java简介 1.1、认识 1.2、java的发展史 1.3、java语言的主要特点 1.4、java 两种核心机制 1.5、JRE、JDK、JVM之间的区别与联系 2、Java开发环境搭建 2.1、JDK的安装 2.2、配置JDK环境变量 2.3、流行JAVA开发工具 3、Java 基础语法 3.1、第一个Java程序 3.2、基本语法 3....
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1119
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
xiaocaij_icai的博客
09-15 157
");
基于SpringBoot的考研资讯平台设计与实现
linzhongshu的专栏
09-13 892
对于本次的系统开发来看，它主要是把我以前所学的知识进行了一次综合的应用。经过这次毕业设计的制作它主要是把我以前所学的理论知识应用到社会实践当中。通过这一次的考研资讯平台的设计与实现它能够有效把计算机知识与实际问题相互应用，通过计算机网络技术来解决学生生活当中的实际问题，从而提高我的编程能力。虽然在这次毕业设计当中我遇到了很多的问题和困难，但是通过不断的调试和老师的帮助让我圆满的完成了这次毕业设计。
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 928
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
spring security中几大组件的作用和执行顺序
阿信今天的代码没bug的博客
09-11 349
spirng security中的几大组件的差异和执行顺序
模拟面试后端开发复盘
Java小白的博客 致力分享每一天学到的知识
09-11 1212
一般来说系统的开发和设计思路的话，就是一般现在的项目基本上都是前后端分离架构来实现的，所以在项目的设计时，要分层次结构来划定。前后端分离架构中，前端一般是有专业的前端工程师来写的，因此我们步需要过分的关注前端，可以在github上找到相关的前端项目即可。
计算机毕业设计 网上书店系统 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-16 855
本文介绍了一款基于Java、SpringBoot和Vue.js技术的网上书店系统。该系统为管理员、用户和卖家提供了图书信息浏览、订单管理、个人中心管理等功能，旨在打造一个便捷、高效的在线购书平台。系统通过优化图书销售流程，提升用户体验，推动出版行业的数字化转型，促进知识传播和文化交流。
使用API有效率地管理Dynadot域名，查看域名服务器（NS）信息
Dynadot_tech的博客
09-12 1073
Dynadot是通过ICANN认证的域名注册商，自2002年成立以来，服务于全球108个国家和地区的客户，为数以万计的客户提供简洁，优惠，安全的域名注册以及管理服务。Dynadot.com提供的API是专为效率而构建的高级域名管理和获取工具包。使用Dynadot API，可以查看某一域名DNS设置的域名服务器（Name server）信息。
07_Python数据类型_集合
最新发布
fx_yzjy101的专栏
09-16 422
可以使用大括号 {} 或者 set() 函数来创建集合。如果使用大括号，则至少需要包含一个元素；如果使用 set()，则可以创建一个空集合。# 创建一个空集合# 创建一个包含一个元素的集合# 创建一个包含几个元素的集合。
Java圣思园基础笔记：类与对象、重载与继承详解
1. 类与对象：Java中，类是一种抽象概念，它定义了一组相似属性和行为的模板，而对象则是类的具体实例。类与对象的关系类似于蓝图和建筑物，类是设计，对象是实体。 2. 类的构成：每个类都包含属性（属性通常用名词...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值