java-面向对象（中）

最新推荐文章于 2022-07-25 17:51:09 发布
最新推荐文章于 2022-07-25 17:51:09 发布
阅读量63 收藏
点赞数
分类专栏： java笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41359273/article/details/115864383
版权

1.面向对象的第二特征：继承
继承的好处：
1）减少了代码的冗余，提高了代码的复用性
2）便于功能的扩展
3）为之后多态性的使用，提供了前提

2.继承的基本概念

package com.yl.pdfdemo.day04.p1;

/**
 * @Author wfj
 * @Date 2021/3/29
 * @Description
 * @Version 1.0
 */

public class Creature {
    public void run() {
        System.out.println("run...");
    }
}


package com.yl.pdfdemo.day04.p1;

/**
 * @Author wfj
 * @Date 2021/3/29
 * @Description
 * @Version 1.0
 */

public class Person extends Creature{

    String name;
    private int age;

    public Person() {

    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public Person(String name,int age) {
        this.name = name;
        this.age = age;
    }

    public void eat() {
        System.out.println("eat...");
    }

    public void say() {
        System.out.println("say...");
    }
}


package com.yl.pdfdemo.day04.p1;

/**
 * @Author wfj
 * @Date 2021/3/29
 * @Description
 * @Version 1.0
 */

public class Student extends Person{

//    String name;
//    int age;
    int grade;

    public Student() {

    }

    public Student(String name,int age,int grade) {
        this.name = name;
        setAge(age);
        this.grade = grade;
    }

//    public void eat() {
//        System.out.println("eat..");
//    }
//
//    public void say() {
//        System.out.println("say...");
//    }

    public void study() {
        System.out.println("study...");
    }
}


package com.yl.pdfdemo.day04.p1;

/**
 * @Author wfj
 * @Date 2021/3/29
 * @Description 面向对象的特征之二：继承
 * @Version 1.0
 */

public class ExtTest1 {

    public static void main(String[] args) {
        /**
         * 一、继承的好处
         * 1.减少了代码的冗余，提高了代码的复用性
         * 2.便于功能的扩展
         * 3.为之后多态性的使用，提供了前提
         *
         * 二、继承的格式：class A extends B{}
         *  A:子类，派生类，subclass
         *  B：父类，超类，基类，superclass
         *
         *  2.1体现：一旦子类A继承了父类B以后，子类A中就获取了父类中声明的所有属性和方法（包括私有的）
         *      父类中声明的私有的属性和方法，子类继承父类后，仍然认为获取了父类中私有的属性和方法
         *     只是因为封装性的影响，使得之类不能直接调用父类的的结构而已
         *
         * 2.2 子类继承父类以后，还可以声明自己持有的属性或者方法，实现功能的拓展
         *
         * 三、java中关于继承的规定
         *      1.一个类可以被多个子类继承
         *      2.一个类只能有一个父类：单继承
         *      3.子父类是相对的概念
         *      4.子类直接继承的父类，称为直接父类，间接继承的父类称为间接父类
         *      5.子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法
         *
         * 四、1.如果我们没有显式的声明一个类的父类的话，则此类继承于java.lan.Object
         *     2.所有的java类（除java.lan.Object类）外，都直接或间接继承于java.lang.Object
         *     3.意味着，所有的java都具有Object的java.lan.Objec类声明的功能
         *     */
        Person person = new Person();
        person.setAge(19);
        person.say();

        Student student = new Student();
        student.setAge(10);
        student.name = "xiao";
        student.say();
        student.study();
        student.run();

    }
}

3.方法重写使用

package com.yl.pdfdemo.day04.p2;

/**
 * @Author wfj
 * @Date 2021/3/29
 * @Description
 * @Version 1.0
 */

public class Person {
    String name;
    int age;

    public Person() {

    }
    public Person(String name,int age) {
        this.name = name;
        this.age = age;
    }

    public void eat() {
        System.out.println("eat...");
    }

    public void say() {
        System.out.println("say...");
    }
}


package com.yl.pdfdemo.day04.p2;

/**
 * @Author wfj
 * @Date 2021/3/29
 * @Description
 * @Version 1.0
 */

public class Student extends Person{

    String gender;

    public Student() {

    }

    public Student(String gender) {
        this.gender = gender;
    }

    public void study() {
        System.out.println("study...");
    }

    public void eat() {
        System.out.println("student eat...");
    }
}


package com.yl.pdfdemo.day04.p2;

/**
 * @Author wfj
 * @Date 2021/3/29
 * @Description 方法重写
 * @Version 1.0
 */

public class PersonTest {
    public static void main(String[] args) {
        /**
         * 方法的重写：（overrite / overwrite）
         * 1.重写：子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖
         *
         * 2.应用：重写后，当创建子类对象后，通过子类对象调用子父类中同名同参数的方法时，实际执行的是子类中的那个方法
         *
         * 面试题：重载和重写有什么区别？
         *
         *  概念：
         *      重载=》在同一个类中，可以声明多个方法名称相同，形参列表不同的方法，构造器也可以进行重载
         *      重写=》子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作
         *      重载：不表现多态性
         *      重写：表现为多态性
         *
         * 3.重写的规定：
         *      方法的声明： 访问权限修饰符  返回值类型   方法名（形参列表）throws 异常类型{方法体}
         *      约定俗称：子类中的叫重写的方法，父类中叫被重写的方法
         *  3.1 子类重写的方法的方法名和形参列表和父类的被重写方法的方法名和形参列表相同
         *
         *  3.2 子类重写的方法的权限访问修饰符不小于父类被重写方法的权限访问修饰符
         *      》特殊情况，子类不能重写父类中声明为private的方法
         *
         *  3.3 返回值类型
         *      》如果父类中被重写的方法的返回值类型是void,那么子类中重写的方法返回也必须是void
         *      》父类中被重写都方法的返回值的类型是A，那么子类中重写的方法的返回值可以是A类，或者A类的子类
         *      》如果父类中被重写的方法的返回值类型是基本数据类型,那么子类中重写的方法返回也必须是对应的基本数据类型
         *
         *  3.4 子类重写的方法抛出的异常类型不大于父类中被重写方法说抛出的异常类型
         *
         *      子类和父类中的同名同参数的方法要么都声明为非static的（考虑重写）,要么都声明为static(不是重写)
         */
        Student student = new Student("男");
        student.eat();
        student.say();
        student.study();
    }
}

4.super关键字的使用

package com.yl.pdfdemo.day04.p3;

/**
 * @Author wfj
 * @Date 2021/3/29
 * @Description
 * @Version 1.0
 */

public class Person {
    String name;
    int age;
    int id = 100;

    public Person() {

    }
    public Person(String name) {
        this.name = name;
    }
    public Person(String name,int age) {
        //这里用this调用了带有一个参数的构造器
        this(name);
        this.age =age;
    }
    public void eat() {
        System.out.println("eat...");
    }
    public void say() {
        System.out.println("say...");
    }
    public void sing() {
        System.out.println("sing...");
    }
}


package com.yl.pdfdemo.day04.p3;

/**
 * @Author wfj
 * @Date 2021/3/29
 * @Description
 * @Version 1.0
 */

public class Student extends Person {
    String gender;
    int id = 101;
    public Student() {
    }
    public Student(String name,int age,String gender) {
        super(name,age);
        this.gender = gender;
    }
    public Student(String gender) {
        this.gender = gender;
    }
    @Override
    public void eat() {
        System.out.println("student eat...");
    }
    public void study(){
        System.out.println("student study...");
    }
    public void show() {
        // 会在当前类找有没有这个属性，有的话直接用，没有的话就再去父类找
        System.out.println("name="+name+",age="+age);
        // 如果父类和子类存在相同的属性，那么子类默认会使用自己的属性值
        System.out.println("子类id="+id); // 101(省略了this)
        System.out.println("父类id="+super.id); // 100
        eat();// 相当于this.eat()
        super.eat(); // 调用父类的eat
        this.sing(); // 会在本类找该方法，如果没有就去父类找
        super.sing();// 调用父类方法
        sing();//会在本类找该方法，如果没有就去父类找
    }
}


package com.yl.pdfdemo.day04.p3;

/**
 * @Author wfj
 * @Date 2021/3/29
 * @Description super关键字的使用
 * @Version 1.0
 */

public class SuperTest {
    public static void main(String[] args) {
        /**
         * super的使用
         * 1.super理解为：父类的
         * 2.super可以用来调用：属性，方法，构造器
         *
         * 3.super的使用：调用属性或者方法
         *
         * 3.1 我们可以在子类的方法或者构造器中，通过super.属性或者super.方法的方式，显式的调用父类中声明的属性或方法，但是通常省略super
         *
         *  特别地： 1)当子类和父类定义了相同名称的属性时，我们要在子类中调用父类中声明的属性，就必须要用super来调用
         *          2)当子类重写父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须使用super来调用
         *
         *4.super调用构造器
         *      1) 我们可以在子类的构造器中显式的使用super(形参列表)的形式，调用父类中指定的构造器
         *      2） super（形参列表）的使用，必须声明在子类的首行
         *      3） 我们在类的构造器中，this(形参列表)，super(形参列表)只能出现一个，不能同时出现
         *      4）在构造器首行，没有显式的声明this(形参列表)，super(形参列表)，则默认调用的父类中空参的构造器
         *      5） 在类的多个构造器中，至少有一个类的构造器使用了super(形参列表)，调用父类的构造器
         *
         * 5.子类对象实例化过程
         *      1） 从结果上看：（继承性）
         *          子类继承父类以后，就获取了父类中声明的属性或方法
         *          创建子类的对象，在堆空间中，就会加载父类的所有的属性
         *
         *      2）从过程上看：
         *          当我们通过子类的构造器创建子类对象时，我们一定会间接或者直接的调用了父类的构造器，进而调用父类的父类的构造器
         *          直到调用了java.lang.Object的空参构造器为止，正因为加载过所有的父类的结构，所以才看到内存中有父类的中的结构，
         *          子类对象才可以进行调用
         */
        Student student = new Student();
        student.show();
        System.out.println("++++++++++++++++++++++=");
        Student s1 = new Student("小明",18,"男");
        s1.show();
    }
}

5.练习1

package com.yl.pdfdemo.day04.p1;

/**
 * @Author wfj
 * @Date 2021/3/29
 * @Description
 * @Version 1.0
 */

public class Circle {
    private double radius;

    public Circle() {
        radius = 0.1;
    }
    public void setRadius(double radius) {
        this.radius = radius;
    }
    public double getRadius() {
        return radius;
    }

    public double findArea() {
        return Math.PI * radius * radius;
    }
}


package com.yl.pdfdemo.day04.p1;

/**
 * @Author wfj
 * @Date 2021/3/29
 * @Description
 * @Version 1.0
 */

public class Cylinder extends Circle {

    private double length;

    public Cylinder() {
        length = 1;
    }

    public void setLength(double length) {
        this.length = length;
    }

    public double getLength() {
        return length;
    }

    // 求圆柱体积
    public double findVolume() {
        return findArea() * length;
    }
}


package com.yl.pdfdemo.day04.p1;

/**
 * @Author wfj
 * @Date 2021/3/29
 * @Description 继承练习
 * @Version 1.0
 */

public class CycleTest {

    public static void main(String[] args) {
       Cylinder cylinder = new Cylinder();
       cylinder.setRadius(2.1);
       cylinder.setLength(5);
        System.out.println("圆柱的体积为：" + cylinder.findVolume());

    }
}

6.练习2

package com.yl.pdfdemo.day04.p1;

/**
 * @Author wfj
 * @Date 2021/3/29
 * @Description
 * @Version 1.0
 */

public class ManKind {

    private int sex;
    private int salary;

    public void setSex(int sex) {
        this.sex = sex;
    }
    public int getSex() {
        return sex;
    }
    public void setSalary(int salary) {
        this.salary = salary;
    }
    public void manOrWoman() {
        if (sex == 1) {
            System.out.println("man");
        } else {
            System.out.println("woman");
        }
    }

    public void employee() {
        if (salary == 0) {
            System.out.println("no job");
        } else {
            System.out.println("job");
        }
    }


}


package com.yl.pdfdemo.day04.p1;

/**
 * @Author wfj
 * @Date 2021/3/29
 * @Description
 * @Version 1.0
 */

public class Kids extends ManKind {

    private int yearsOid;

    public Kids(){

    }
    public Kids(int yearsOid) {
        this.yearsOid = yearsOid;
    }
    public void printAge() {
        System.out.println(yearsOid);
    }
}


package com.yl.pdfdemo.day04.p1;

/**
 * @Author wfj
 * @Date 2021/3/29
 * @Description 继承练习
 * @Version 1.0
 */

public class KidsTest {
    public static void main(String[] args) {
        Kids kids = new Kids();
        kids.setSex(1);
        kids.setSalary(1000);
        kids.manOrWoman();
        kids.employee();
    }
}

7.练习3

package com.yl.pdfdemo.day04.p3;

/**
 * @Author wfj
 * @Date 2021/3/30
 * @Description
 * @Version 1.0
 */

public class Account {
    private int id; // 账号

    private double balance; //余额

    private double annualInterestRate; // 年利率

    public Account() {

    }

    public Account (int id,double balance,double annualInterestRate) {
        super();
        this.id = id;
        this.balance = balance;
        this.annualInterestRate = annualInterestRate;
    }
    public void setId(int id) {
        this.id = id;
    }
    public int getId() {
        return id;
    }
    public void setBalance(double balance) {
        this.balance = balance;
    }
    public double getBalance() {
        return balance;
    }
    public void setAnnualInterestRate(double annualInterestRate) {
        this.annualInterestRate = annualInterestRate;
    }
    public double getAnnualInterestRate() {
        return annualInterestRate;
    }
    //返回月利率
    public double getMonthlyInterest() {
        return annualInterestRate / 12;
    }
    //取钱
    public void withdraw(double amount) {
        if (balance >= amount) {
            balance -= amount;
            return;
        }
        System.out.println("余额不足");
    }

    //存钱
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
}


package com.yl.pdfdemo.day04.p3;

/**
 * @Author wfj
 * @Date 2021/3/30
 * @Description
 * @Version 1.0
 */

public class CheckAccount extends Account{
    private double overDraft; // 可透支限额

    public void setOverDraft(double overDraft) {
        this.overDraft = overDraft;
    }
    public double getOverDraft() {
        return overDraft;
    }
    public CheckAccount(int id,double balance,double annualInterestRate,double overDraft) {
        super(id,balance,annualInterestRate);
        this.overDraft = overDraft;
    }
    //重写取钱方法
    @Override
    public void withdraw(double amount) {
//        getBalance() -= amount; 错误写法
        if (getBalance() >= amount) { // 余额足够消费
            //方式一
            //setBalance(getBalance() - amount);
            // 方式二
            super.withdraw(amount);
        } else if (overDraft >= amount - getBalance()) { // 透支额度+余额足够消费
            overDraft -= (amount - getBalance());
            setBalance(0);
        } else {
            System.out.println("超过可透支限额");
        }
    }
}


package com.yl.pdfdemo.day04.p3;

/**
 * @Author wfj
 * @Date 2021/3/30
 * @Description
 * @Version 1.0
 */

public class AccountTest {
    public static void main(String[] args) {
        Account account = new Account(111,20000,0.045);

        account.withdraw(30000);
        System.out.println("您的余额为：" + account.getBalance());
        account.withdraw(2500);
        System.out.println("您的余额为：" + account.getBalance());
        account.withdraw(1000);
        System.out.println("您的余额为：" + account.getBalance());

        System.out.println("月利率为：" + (100 * account.getMonthlyInterest()) + "%");
    }
}


package com.yl.pdfdemo.day04.p3;

/**
 * @Author wfj
 * @Date 2021/3/30
 * @Description
 * @Version 1.0
 */

public class CheckAccountTest {
    public static void main(String[] args) {
        CheckAccount account = new CheckAccount(1122,2000,0.045,5000);
        account.withdraw(5000);
        System.out.println("您的账户余额为：" + account.getBalance());
        System.out.println("您的可透支额度为：" + account.getOverDraft());
        account.withdraw(1800);
        System.out.println("您的账户余额为：" + account.getBalance());
        System.out.println("您的可透支额度为：" + account.getOverDraft());
        account.withdraw(3000);
        System.out.println("您的账户余额为：" + account.getBalance());
        System.out.println("您的可透支额度为：" + account.getOverDraft());

    }
}
#Hideonbush
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
jmu-Java-03面向对象基础-04-形状-继承 PTA
qq_43427314的博客
10-31 3335
jmu-Java-03面向对象基础-04-形状-继承 PTA题目本题描述：思考分析答案 题目 前面题目形状中我们看到，为了输出所有形状的周长与面积，需要建立多个数组进行多次循环。这次试验使用继承与多态来改进我们的设计。 本题描述： 1.定义抽象类Shape 属性：不可变静态常量double PI，值为3.14， 抽象方法:public double getPerimeter(),public double getArea() 2.Rectangle与Circle类均继承自Shape类。 Rectangle类
java-面向对象特性PPT.ppt
10-31
本资源摘要信息主要讲解了面向对象编程的基本概念、面向对象设计、类和对象的概念、Java中的类和对象的使用等知识点。 面向对象编程是一种编程思想，强调以对象为中心来思考问题。面向对象编程的出现是为了解决传统...
Java-面向对象 练习题
dayu
01-30 8808
知识点 面向对象 题目1（训练） 定义手机类，手机有品牌(brand),价格(price)和颜色(color)三个属性，有打电话call()和sendMessage()两个功能。 请定义出手机类，类中要有空参、有参构造方法，set/get方法。 定义测试类，在主方法中使用空参构造创建对象，使用set方法赋值。 调用对象的两个功能，打印效果如下： 正在使用价格为3998元黑色的小米手机打电话.... 正在使用价格为3998元黑色的小米手机发短信.... 训练提示 类中的属性就是成员变量
java基础-面向对象
codeglory的博客
04-21 6204
java基础部分-面向对象的概念，类之间关系，并部分解释了UML类图
jmu-Java-03面向对象基础-05-覆盖
琉璃轻纱的博客
12-06 1596
PTA
（Java）7-1 jmu-Java-03面向对象基础-04-形状-继承
wxw1920的博客
07-25 2038
代码】（Java）7-1jmu-Java-03面向对象基础-04-形状-继承。
java-面向对象-属性默认值
ITGGU的博客
01-11 2595
面向对象-属性默认值 对象的属性默认值，遵守数组的规则 int 0 ， short 0 , long 0 , float 0.0 ,double 0.0 ,char \u000，boolean false; public class Object01 { public static void main(String[] args) { //对象的属性默认值，遵守数组的规则 Person p1 = new Person(); System.out.println("输出当前这个人的信息:")
java学习---面向对象基础
MTYSYS19990212的博客
05-07 2597
1、面向对象基础 1.1、 面向对象思想 1.1.1、 概述 面向对象(Object Oriented)是软件开发方法，一种编程范式。面向对象的概念和应用已超越了程序设计和软件开发，扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。面向对象是一种对现实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。 面向对象是相对于面向过程来讲的，面向对象方法，把相关的数据和方法组织为一个整体来看待，从更高的层次来进行系统建模，更贴近事物的自然运行模
Java-面向对象
热门推荐
qq_37806415的博客
02-14 1万+
软件生命周期: 软件生命周期: 软件的产生直到报废的整个过程. 软件生命周期内有：问题定义, 可行性分析, 总体描述, 系统设计,编码, 调试和测试, 验收与运行, 维护升级到废弃等阶段 1）：问题的定义及规划: 此阶段是软件开发方与需求方共同讨论，主要确定软件的开发目标及其可行性。 2）：需求分析: 在确定软件开发可行的情况下，对软件需要实现的各功能进行详细分析。需求分析阶段是一个很重要的阶段，...
Java面向对象浅谈
编程界明世隐的博客
12-06 4924
作者简介 作者名：编程界明世隐 简介：CSDN博客专家，从事软件开发多年，精通Java、JavaScript，博主也是从零开始一步步把学习成长、深知学习和积累的重要性，喜欢跟广大ADC一起打野升级，欢迎您关注，期待与您一起学习、成长、起飞！ 热门专栏推荐 【1】Java小游戏（俄罗斯方块、飞机大战、植物大战僵尸等） 【2】JavaWeb项目实战（图书管理、在线考试、宿舍管理等） 【3】JavaScript精彩实例（飞机大战、贪吃蛇、验证码等） 【4】Java小白入门200例 【5】从零学Java、趣学J
jmu-Java-03面向对象基础-01-构造函数与toString(Java)
weixin_51430516的博客
03-23 8926
定义一个有关人的Person类，内含属性： String name、int age、boolean gender、int id，所有的变量必须为私有 (private) 。 注意：属性顺序请严格按照上述顺序依次出现。 ###1.编写无参构造函数： 打印"This is constructor"。 将name,age,gender,id按照name,age,gender,id格式输出 ###2.编写有参构造函数 依次对name,age,gender赋值。 ###3.覆盖toString函数： 按照格式：**类
Java-面向对象设计-类和对象.docx
12-16
Java面向对象设计类和对象是面向对象程序设计的基础，它将现实世界模型自然延伸到程序设计中。类和对象是面向对象设计的核心概念，类描述对象的属性和行为，对象是类的实例，是一个实实在在的个体。 类是对象的模板...
java-面向对象的英雄类
12-20
在这个“java-面向对象的英雄类”主题中，我们将深入探讨Java中的面向对象编程，特别是继承的概念，这是Java OOP的三大特性（封装、继承和多态）之一。 面向对象编程的基本理念是将现实世界中的实体抽象为类，类是...
Java教程-面向对象设计
06-17
Java教程—面向对象设计；Java教程—面向对象设计；Java教程—面向对象设计Java教程—面向对象设计
Java知识-面向对象思维导图
最新发布
04-02
Java知识-面向对象思维导图
windows常用的命令行指令
weixin_41359273的博客
01-03 3516
1.windows + r 然後輸入cmd即可進入到終端 2.切換到某一個硬盤，d: 這裏切換到d盤 3.顯示當前文件下所有的文件夾，dir命令 4.新建一個文件夾，md 文件夾名 5.如何進入到某一個文件夾，cd 文件夾路徑 6.退回上一個文件夾位置，cd…,如下在test裏又建了三個文件夾，我們先進入到test文件夾中，再返回到test所在的位置 7.回到根目錄下，通過cd\或者cd/都行 8.將指定内容生成到一個文件裏去，如下為將singjumprap寫道一個doc文件裏去 9.刪除某一個文件
java 注解的基本使用
weixin_41359273的博客
06-11 1180
1.注解含义：注解其实就是代码里特殊的标志，这些标志可以在编译，类加载，运行时被读取，并执行相应的处理，注解可以像修饰符一样使用，可用于修饰包，类，构造器， 2.自定义注解 package com.yl.pdfdemo.day08.p1; import java.lang.annotation.*; import static java.lang.annotation.ElementType.*; import static java.lang.annotation.ElementType.LOCAL_
java BigInteger,BigDecimal基本使用
weixin_41359273的博客
06-11 1047
package com.yl.pdfdemo.day08.p1; import org.junit.Test; import java.math.BigDecimal; import java.math.BigInteger; /** * @Author wfj * @Date 2021/6/9 * @Description * @Version 1.0 */ public class OtherClassTest { //System类的相关方法 @Test p
java--if-else的基本使用
weixin_41359273的博客
01-10 544
package com.yl.pdfdemo.day01; /** * @Author wfj * @Date 2021/1/10 * @Description if else 结构的基本使用 * @Version 1.0 */ public class IfTest { public static void main(String[] args) { /** * 分支结构中的if-else(条件判断结构) * *
Java语言程序设计入门-面向对象详解
为了辅助学习，课程提供了多本参考教材，如《Java语言程序设计》、《Java2实用教程》、《Java面向对象编程》等，鼓励学生广泛阅读并动手实践。课程采用课堂理论与实践相结合的方式，辅以课堂练习、课后练习和上机...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值