0216-0218复习：继承

最新推荐文章于 2024-06-09 18:24:15 发布
最新推荐文章于 2024-06-09 18:24:15 发布
阅读量669 收藏
点赞数
分类专栏： java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wjkqq0921/article/details/128946177
版权

目录

继承

一、基本介绍

二、示意图

三、基本语法

四、入门案例

父类

子类1

子类2

main方法

五、继承细节

第一条

第二条

第三条

第四条

​编辑 第五条

 第六条

第七条

第八条

第九条

第十条

六、继承本质

七、练习题

第三题

继承

一、基本介绍

继承可以解决代码冗余过高的问题，将两个或多个类中相同的属性和方法提取出来，放在一个类中，称其为父类，子类继承父类，就是继承了这些属性和方法（不需要再次说明），同时，子类中也可以有其特有的属性和方法

二、示意图

三、基本语法


子类 extends 父类{
子类特有的属性和发方法
} 

注意事项：子类中一定要加关键字extends

四、入门案例

父类

package com.hspedu.extend_;

public class Student {//父类
    public String name;
    public int age;
    private double score;

    public void setScore(double score) {
        this.score = score;
    }
    public void showInfo(){
        System.out.println("学生名 " + name + " 年龄 " + age + " 成绩 " + score);
    }
}

子类1

package com.hspedu.extend_;

public class Pupil extends Student{
    public void testing() {
        System.out.println("小学生 " + name + " 正在考小学数学..");
    }
}

子类2

package com.hspedu.extend_;

public class Graduate extends Student{
    public void testing() {//和 Pupil 不一样
        System.out.println("大学生 " + name + " 正在考大学数学..");
    }
}

main方法

package com.hspedu.extend_;

public class Extends01 {
    public static void main(String[] args) {
        Graduate graduate = new Graduate();
        graduate.name = "金角大王";
        graduate.age = 21;
        graduate.testing();
        graduate.setScore(87);
        graduate.showInfo();

        System.out.println("===============");
        Pupil pupil = new Pupil();
        pupil.name = "银角大王";
        pupil.age = 11;
        pupil.testing();
        pupil.setScore(90);
        pupil.showInfo();
    }

}

控制台输出结果

五、继承细节

第一条

子类继承了父类所有的属性和方法，非私有的属性和方法可以在子类直接访问，私有属性不能在子类直接访问，要通过父类的public方法去访问

父类

package com.hspedu.extend_;

public class Base {//父类
    //四个属性，四个访问修饰符
    public int n1 = 100;
    protected int n2 = 200;
    int n3 = 300;
    private int n4 = 400;


    //默认的无参构造器
    public Base() {
        System.out.println("Base()....");
    }
    //四个方法，访问修饰符对应四个属性
    public void test100(){
        System.out.println("test100");
    }
    protected void test200(){
        System.out.println("test200");
    }
    void test300(){
        System.out.println("test300");
    }
    private void test400(){
        System.out.println("test400");
    }

}

子类

package com.hspedu.extend_;

public class Sub extends Base{//子类
    public Sub() {
        System.out.println("Sub()....");
    }
    public void sayOk(){
        //除了private属性和方法之外都可以访问
        
    }

}

子类中不能访问父类中的private属性和方法

要通过父类提供的public方法去访问 

package com.hspedu.extend_;

public class Base {//父类
    //四个属性，四个访问修饰符
    public int n1 = 100;
    public final int n5 = 500;
    protected int n2 = 200;
    int n3 = 300;
    private int n4 = 400;


    //默认的无参构造器
    public Base() {
        System.out.println("Base()....");
    }

    //父类提供一个public方法，子类可以访问父类的private属性
    public int getN4(){
        return n4;
    }

    //四个方法，访问修饰符对应四个属性
    public void test100(){
        System.out.println("test100");
    }
    protected void test200(){
        System.out.println("test200");
    }
    void test300(){
        System.out.println("test300");
    }
    private void test400(){
        System.out.println("test400");
    }
    //父类提供一个public方法，子类可以访问父类的private方法
    public void callTest400(){
        test400();
    }

}

package com.hspedu.extend_;

public class Sub extends Base{//子类
    public Sub() {
        System.out.println("Sub()....");
    }
    public void sayOk(){
        //除了private属性和方法之外都可以访问
        System.out.println(n1 + " " + n2 + " " + n3);
        test100();
        test200();
        test300();
        //test400();
        System.out.println("n4= " + getN4());
        callTest400();//中转
    }

}


package com.hspedu.extend_;

public class ExtendsDetail {
    public static void main(String[] args) {
        //细节说明
        Sub sub = new Sub();
        sub.sayOk();
    }
}

第二条

子类必须调用父类的构造器， 完成父类的初始化


第三条

当创建子类对象时， 不管使用子类的哪个构造器， 默认情况下总会去调用父类的无参构造器， 如果父类没有提供无参构造器， 则必须在子类的构造器中用 super 去指定使用父类的哪个构造器完成对父类的初始化工作， 否则， 编译不会通过

package com.hspedu.extend_;

public class Base {//父类
    //四个属性，四个访问修饰符
    public int n1 = 100;
    public final int n5 = 500;
    protected int n2 = 200;
    int n3 = 300;
    private int n4 = 400;


    //默认的无参构造器
//    public Base() {
//        System.out.println("父类Base()的构造器被调用....");
//    }
    //父类的有参构造器
    public Base(String name, int age){
        System.out.println("父类的(String name, int age)构造器被调用....");
    }

    //父类提供一个public方法，子类可以访问父类的private属性
    public int getN4(){
        return n4;
    }

    //四个方法，访问修饰符对应四个属性
    public void test100(){
        System.out.println("test100");
    }
    protected void test200(){
        System.out.println("test200");
    }
    void test300(){
        System.out.println("test300");
    }
    private void test400(){
        System.out.println("test400");
    }
    //父类提供一个public方法，子类可以访问父类的private方法
    public void callTest400(){
        test400();
    }

}

package com.hspedu.extend_;

public class Sub extends Base{//子类
    public Sub() {
        //super();//隐藏的，创建子类对象的时候会默认调用父类的无参构造器
        super("smith",20);//当父类的无参构造器被覆盖时，用super指定调用父类的构造器
        System.out.println("子类Sub()构造器被调用....");
    }
    //当创建子类对象时， 不管使用子类的哪个构造器， 默认情况下总会去调用父类的无参构造器
    public Sub(String name){
        super("smith",20);
        System.out.println("子类Sub(String name)构造器被调用....");
    }
    public void sayOk(){
        //除了private属性和方法之外都可以访问
        System.out.println(n1 + " " + n2 + " " + n3);
        test100();
        test200();
        test300();
        //test400();
        System.out.println("n4= " + getN4());
        callTest400();//中转
    }

}

package com.hspedu.extend_;

public class ExtendsDetail {
    public static void main(String[] args) {
        //细节说明
        Sub sub = new Sub();
        System.out.println("=========第二个对象==========");
        Sub sub2 = new Sub("jack");
        //sub.sayOk();

    }
}

第四条

如果希望指定去调用父类的某个构造器， 则显式的调用一下 : super(参数列表)

package com.hspedu.extend_;

public class Base {//父类
    //四个属性，四个访问修饰符
    public int n1 = 100;
    public final int n5 = 500;
    protected int n2 = 200;
    int n3 = 300;
    private int n4 = 400;


    //默认的无参构造器
    public Base() {
        System.out.println("父类Base()的构造器被调用....");
    }
    //父类的有参构造器，两个参数
    public Base(String name, int age){
        System.out.println("父类的(String name, int age)构造器被调用....");
    }
    //一个参数的构造器
    public Base(String name){
        System.out.println("父类的(String name)构造器被调用....");
    }

    //父类提供一个public方法，子类可以访问父类的private属性
    public int getN4(){
        return n4;
    }

    //四个方法，访问修饰符对应四个属性
    public void test100(){
        System.out.println("test100");
    }
    protected void test200(){
        System.out.println("test200");
    }
    void test300(){
        System.out.println("test300");
    }
    private void test400(){
        System.out.println("test400");
    }
    //父类提供一个public方法，子类可以访问父类的private方法
    public void callTest400(){
        test400();
    }

}

package com.hspedu.extend_;

public class Sub extends Base{//子类
    public Sub(String name, int age){
        //1.调用父类的无参构造器,两种方式：一是super(); 二是什么都不写
        //super();
        //2.调用父类Base(String name)的构造器
        //super("smith");

        //3.调用父类Base(String name, int age)的构造器
        super("smith",25);
        System.out.println("子类的(String name, int age)构造器被调用....");
    }
    public Sub() {
        //super();//隐藏的，创建子类对象的时候会默认调用父类的无参构造器
        super("smith",20);//当父类的无参构造器被覆盖时，用super指定调用父类的构造器
        System.out.println("子类Sub()构造器被调用....");
    }
    //当创建子类对象时， 不管使用子类的哪个构造器， 默认情况下总会去调用父类的无参构造器
    public Sub(String name){
        super("smith",20);
        System.out.println("子类Sub(String name)构造器被调用....");
    }
    public void sayOk(){
        //除了private属性和方法之外都可以访问
        System.out.println(n1 + " " + n2 + " " + n3);
        test100();
        test200();
        test300();
        //test400();
        System.out.println("n4= " + getN4());
        callTest400();//中转
    }

}

package com.hspedu.extend_;

public class ExtendsDetail {
    public static void main(String[] args) {
        //细节说明
//        Sub sub = new Sub();
//        //sub.sayOk();
//        System.out.println("=========第二个对象==========");
//        Sub sub2 = new Sub("jack");
        System.out.println("=========第三个对象==========");
        Sub sub3 = new Sub("ada", 46);


    }
}

 
第五条

super 在使用时， 必须放在构造器第一行(super 只能在构造器中使用)

 第六条

super() 和 this() 都只能放在构造器第一行， 因此这两个方法不能共存在一个构造器

第七条

java 所有类都是 Object 类的子类, Object 是所有类的基类
 

 TopBase类

public class TopBase {//父类是Object类
    public TopBase() {
        System.out.println("构造器TopBase()被调用...");
    }
}

Base类

package com.hspedu.extend_;

public class Base extends TopBase{//父类
    //四个属性，四个访问修饰符
    public int n1 = 100;
    public final int n5 = 500;
    protected int n2 = 200;
    int n3 = 300;
    private int n4 = 400;


    //默认的无参构造器
    public Base() {
        System.out.println("父类Base()的构造器被调用....");
    }
    //父类的有参构造器，两个参数
    public Base(String name, int age){
        System.out.println("父类的(String name, int age)构造器被调用....");
    }
    //一个参数的构造器
    public Base(String name){
        System.out.println("父类的(String name)构造器被调用....");
    }

    //父类提供一个public方法，子类可以访问父类的private属性
    public int getN4(){
        return n4;
    }

    //四个方法，访问修饰符对应四个属性
    public void test100(){
        System.out.println("test100");
    }
    protected void test200(){
        System.out.println("test200");
    }
    void test300(){
        System.out.println("test300");
    }
    private void test400(){
        System.out.println("test400");
    }
    //父类提供一个public方法，子类可以访问父类的private方法
    public void callTest400(){
        test400();
    }

}

Sub类

package com.hspedu.extend_;


//ctrl+H查看继承关系
public class Sub extends Base{//子类
    public Sub(String name, int age){
        //1.调用父类的无参构造器,两种方式：一是super(); 二是什么都不写
        //super();
        //2.调用父类Base(String name)的构造器
        //super("smith");

        //3.调用父类Base(String name, int age)的构造器
        super("smith",25);
        //super() 和 this() 都只能放在构造器第一行， 因此这两个方法不能共存在一个构造器
        //this("jack");//调用本类的Sub(String name)构造器
        System.out.println("子类的(String name, int age)构造器被调用....");

    }
    public Sub() {
        //super();//隐藏的，创建子类对象的时候会默认调用父类的无参构造器
        super("smith",20);//当父类的无参构造器被覆盖时，用super指定调用父类的构造器
        System.out.println("子类Sub()构造器被调用....");
    }
    //当创建子类对象时， 不管使用子类的哪个构造器， 默认情况下总会去调用父类的无参构造器
    public Sub(String name){
        super("smith",20);
        System.out.println("子类Sub(String name)构造器被调用....");
    }
    public void sayOk(){
        //除了private属性和方法之外都可以访问
        System.out.println(n1 + " " + n2 + " " + n3);
        test100();
        test200();
        test300();
        //test400();
        System.out.println("n4= " + getN4());
        callTest400();//中转
    }

}

package com.hspedu.extend_;

public class ExtendsDetail {
    public static void main(String[] args) {
        //细节说明
//        Sub sub = new Sub();
//        //sub.sayOk();
//        System.out.println("=========第二个对象==========");
//        Sub sub2 = new Sub("jack");
        System.out.println("=========第三个对象==========");
        Sub sub3 = new Sub("ada", 46);


    }
}

 

第八条

父类构造器的调用不限于直接父类！ 将一直往上追溯直到 Object 类(顶级父类)


第九条

子类最多只能继承一个父类(指直接继承)， 即 java 中是单继承机制

第十条

不能滥用继承， 子类和父类之间必须满足 is-a 的逻辑关系

六、继承本质

一个继承的代码案例

package com.hspedu.extend_;

/**
 * 讲解继承的本质
 */
public class ExtendsTheory {
    public static void main(String[] args) {
        Son son = new Son();
    }
}
class GrandPa{//爷爷类
    String name = "大头爷爷";
    String hobby = "旅游";
}
class Father extends GrandPa {//父类
    String name = "大头爸爸";
    int age = 39;
   
}
class Son extends Father { //子类
    String name = "大头儿子";
}


1）类加载的顺序

以上代码中创建子类对象，首先在方法区内进行类的加载，加载顺序是Object----->GrandPat----->Fathert----->Son

2)在堆中给对象分配一个地址空间，空间内的属性如下图所示

3)访问时的查找顺序

package com.hspedu.extend_;

/**
 * 讲解继承的本质
 */
public class ExtendsTheory {
    public static void main(String[] args) {
        Son son = new Son();
        //按照查找关系来返回信息
        //(1) 首先看子类是否有该属性
        //(2) 如果子类有这个属性,并且可以访问,则返回信息
        //(3) 如果子类没有这个属性,就看父类有没有这个属性(如果父类有该属性,并且可以访问,就返回信息..)
        //(4) 如果父类没有就按照(3)的规则,继续找上级父类,直到 Object...
        System.out.println(son.name);//大头儿子
        //System.out.println(son.age);//39,不能访问私有属性，但是空间中这个属性依然是存在的
        //通过父类提供的公共方法来访问private属性
        System.out.println(son.getAge());
        System.out.println(son.hobby);//旅游

    }
}
class GrandPa{//爷爷类
    String name = "大头爷爷";
    String hobby = "旅游";
    //Father中的age是private修饰的，不能直接访问，
    // 就算GrandPa中有属性age，也不会跳过Father去访问GrandPa
    int age = 68;
}
class Father extends GrandPa {//父类
    String name = "大头爸爸";
    private int age = 39;
    public int getAge() {
        return age;
    }
}
class Son extends Father { //子类
    String name = "大头儿子";
}

七、练习题

第三题

 Computer类-父类

package com.hspedu.extend_;

public class Computer {
    private String cpu;
    private int memo;
    private int disk;

    public Computer(String cpu, int memo, int disk) {
        this.cpu = cpu;
        this.memo = memo;
        this.disk = disk;
    }

    public String getCpu() {
        return cpu;
    }

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public int getMemo() {
        return memo;
    }

    public void setMemo(int memo) {
        this.memo = memo;
    }

    public int getDisk() {
        return disk;
    }

    public void setDisk(int disk) {
        this.disk = disk;
    }
    public String getDetails(){
        return "CPU:" + cpu + " 内存:" + memo + " 硬盘:" + disk;
    }
}

package com.hspedu.extend_;

public class PC extends Computer{
    private String brand;

    public PC(String cpu, int memo, int disk, String brand) {
        super(cpu, memo, disk);
        this.brand = brand;
    }


    public void printInfo() {
        System.out.print( "PC信息=");
        System.out.println(getDetails() + " 品牌:" + brand);
    }
}

package com.hspedu.extend_;

public class NotePad extends Computer{
    private String color;

    public NotePad(String cpu, int memo, int disk, String color) {
        super(cpu, memo, disk);
        this.color = color;
    }

    public void printInfo() {
        System.out.print( "NotePad信息=");
        System.out.println(getDetails() + " 颜色:" + color);
    }
}

package com.hspedu.extend_;

public class ExtendsExercise03 {
    public static void main(String[] args) {
        PC pc = new PC("AMD", 12, 512, "联想");
        NotePad notePad = new NotePad("Inter", 12, 420, "银灰");
        pc.printInfo();
        notePad.printInfo();
    }
}

 

Sept.1999
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Unity Shader-后处理：高斯模糊
puppet_master的专栏
10-14 2万+
一.简介 上一篇文章学习了模糊的原理以及基本的模糊实现，对于清晰和模糊这个定义感觉还是比较说明问题，这里再贴出一下：“清晰的图片，各个像素之间会有明显的过渡，而如果各个像素之间的差距不是很大，那么图像就会模糊了”。鉴于这个定义，我们就可以通过代码来实现模糊的效果。上一篇Unity Shader-后处理：均值模糊中实现了一个基本的均值模糊，也就是将一个像素和其周围的像素取平均值从而进行
笨方法学习Python-习题42: 物以类聚
土豆拧不成麻花儿的博客
11-10 3680
Python类的学习，Python getattr()方法的学习使用
JavaSE(9)-细节狂魔：OOP之继承多态？20K字长篇看完，有手就行
今年终于不是一个人看烟花了，因为今年没有烟花。
05-01 3702
两万字长篇彻底吃透继承多态思想，对继承多态进行了深入的剖析，图文搭配详解，适合新手深入进阶学习，期末考试复习。
C++复习 -- 继承
mx_jun的博客
05-15 1219
继承是面向对象编程（OOP）中的一个核心概念，特别是在C++中。它允许一个类（称为派生类或子类）继承另一个类（称为基类或父类）的。继承的主要目的是，以及建立一种类型之间的层次关系。
JavaEE应用开发---期末复习题
热门推荐
中国移不动的博客
05-17 1万+
1.singleton（单例模式）：在单例模式下，Spring 容器中只会存在一个共享的 Bean 实例，所有对 Bean 的请求，只要请求的 id（或 name）与 Bean 的定义相匹配，就会返回 Bean 的同一个实例；在Spring MVC中，DispatcherServlet是整个框架的核心，它接收所有的客户端请求，并根据请求中的URL信息，将请求分发给相应的HandlerMapping、HandlerAdapter和Handler进行处理。可以通过此方法对请求域中的模型和视图做出进一步的修改。
尚硅谷-云尚办公-项目复盘
qq_47168235的博客
06-02 2016
本文是作者在练习尚硅谷的云尚办公项目时，遇到的一些问题，问题自上而下顺序记录，当然，也包含一些理论知识的复习与巩固，以及作者对该项目的一些其他的见解。
java期末复习笔记：子类与继承
weixin_46422883的博客
12-27 1498
1.子类与父类在同一个包中：子类继承父类不是private的成员变量和方法。继承的成员变量或方法的访问权限保持不变 2.子类与父类不在同一包中：子类只继承父类中protected和public访问权限的成员变量和方法 3.关于protected： ①一个A类的protected成员变量和方法可以被其子孙类继承 ②对于子类D自己声明的protected成员变量和方法，若other类与D类在同一个包中，则在other类中用D类创建的对象可以访问protected成员变量和方法 ③对于子类D从父类继承的
软件工程---期末复习题
中国移不动的博客
06-05 7296
1、具有风险分析的软件生命周期模型是（ C ）。 A、瀑布模型 B、喷泉模型 C、螺旋模型 D、增量模型2、软件工程的基本要素包括方法、工具和（ A ）。 A、过程 B、软件系统 C、硬件环境 D、人员3、软件的复杂性是（ A ），它引起人员通信困难、开发费用超支、开发时间超时等问题。 A、固有的 B、人为的 C、可消除的 D、不可降低的4、软件过程包括五个框架活动——沟通、策划、建模、构建和部署。其中，哪个活动主要涉及确定软件系统的需求、功能和性能等方面的规范和描述？（ C ） A、沟通 B、策划 C、建
Python基础---面向对象继承及多态
weixin_44239385的博客
01-15 2051
目录 一、继承特性 1.继承的概念 （1）什么是继承 （2）继承中的子类和父类的概念 2.继承的作用 （1）练习1 （2）练习2 3.查看继承的父类 （1）概念 （2）练习 4.方法的复写 （1）概念 （2）练习 5.super() （1）概念 （2）练习 6.__init__()方法 ​ 7.派生属性 8.私有属性私有方法在继承中的表现 9.抽象类 （...
《编译原理》-习题复习
m0_75114363的博客
12-13 2632
博主近期开始了编译原理这门课的复习，在大致地过了一遍基础内容后，我决定开始对于题的练习，今天看了b站上的up主“废物点心v”的题目讲解后，做出了大致的总结。本篇文章仅充当学习分享，如有谬误尽情指正。ps：！！！！！！！！！！！！！！！！！！！！！第一章 绪论_哔哩哔哩_bilibili我今天的主要内容就是基于上面这个视频来的。up讲的很不错，方法很明了清晰！
计算机后端-Java-Java核心基础-第13章 面向对象05 03. 复习：继承性.avi
05-22
计算机后端-Java-Java核心基础-第13章 面向对象05 03. 复习：继承性.avi
FE-Review:前端知识点复习
03-14
JavaScript部分实现CORS TCP三次握手，四次挥手 网络存储深浅拷贝 调用，应用和绑定实现 新实现类数组和参数创建对象方式继承方式节流和防抖 XSS，CSRF，SQL注入 cookie和SameSite HTTP状态码 Http和Https 网络套接...
matlab的eig源码-Application-of-Python-UCLA-PIC16:Python-UCLA-PIC16应用程序
05-19
复习会 1. Python基础 数据类型/结构 模块/功能 异常处理 类和对象（继承） 实例变量，全局变量，私有变量 迭代与生成器 功能图 f =λx：x [0] def g（f，x）：\ n返回f（x）+1 g（lambda x：x [0]，[1,2,3]） 2....
JAVA复习题集(继承).docx
12-18
JAVA复习题集(继承).docx
面向对象技术Java-期末复习试卷(三).docx
12-18
本文档是一个Java期末复习试卷，包含了多个选择题，涵盖了面向对象技术的多个方面，包括Java的基本语法、面向对象的概念、继承、多态、抽象类和接口等。本文档将对每个问题进行详细的解释和分析。 1. 有关Java文件...
自制植物大战僵尸：HTML5与JavaScript实现的简单游戏
m0_73367097的博客
06-08 1914
自制植物大战僵尸
简单的项目部署脚本（转载）
u010230019的博客
06-09 609
有些项目团队喜欢使用docker启动java服务,那么我们同样可以将上述脚本稍做改造,来实现基于shell+docker的简单项目部署能力。可以将核心节点的错误或者失败内容通过webhook发送到对应的告警平台,比如钉钉、飞书机器人等。把~/.ssh/id_rsa.pub内容添加到远程仓库的ssh秘钥中。执行start.sh脚本打包部署。start.sh脚本内容。
Java——简单图书管理系统
最新发布
m0_74100417的博客
06-09 1263
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
修改菜品——后端Java
weixin_53717695的博客
06-09 416
修改菜品——后端Java
python 期末复习具体内容
05-31
- 继承：Python 中的继承使用关键字 extends，可以继承父类的属性和方法。 - 多态：Python 中的多态指同一个方法可以在不同的对象上使用，产生不同的效果。 4. 文件操作 - 打开文件：Python 中使用 open 函数打开...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值