面向对象编程 学习笔记

最新推荐文章于 2023-07-20 20:11:43 发布
最新推荐文章于 2023-07-20 20:11:43 发布
阅读量197 收藏
点赞数
分类专栏： Java 文章标签： java 抽象类 多态 面向对象编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45266679/article/details/109012894
版权

面向对象编程

什么是面向对象

面向对象编程(oop)

面向对象编程的本质就是:以类的方式组织代码,以对象的形式封装数据.

三大特性:

  1. 封装
  2. 继承
  3. 多态

从代码运行角度考虑是先有类后有对象.类是对象的模板.

回顾方法及加深

方法的定义

修饰符

返回类型

break:跳出switch,结束循环和return 的区别

方法名: 注意规范

参数列表:(参数类型,参数名)…

异常抛出

方法的调用

静态方法

非静态方法

形参和实参

值传递和引用传递

this关键字

类和对象关系

类是一种抽象的数据类型,他是对某一事物整体描述/定义,但并不能代表某一个具体的事物.

对象是抽象概念的具体实现

创建和初始化对象

在这里插入图片描述

实例1

package oop.Demo02;
//学生类
public class Student {
    //属性:字段
    String name;
    int age;

    //方法
    public void study(){
        System.out.println(this.name+"在学习");
    }
}



/*

public static void main(String[] args) {

        //类:抽象的,需要实例化

        //类实例化后会返回一个自己的对象!
        //student对象就是一个Student类的具体实例!
//        Student student = new Student();
//        student.name = "小明";
//        System.out.println(student.name);


 */

实例2

package oop.Demo02;
//java---->class
public class Person {

    //一个类即使什么都不写,他也会存在一个定义
    //显示的定义构造器

    String name;

    //实例化初始值
    //构造器作用:
    //1.使用new关键字,本质是在调用构造器
    //2.用来初始化值
    public Person(){

    }
//有参构造   一旦定义了有参构造,无参就必须显示定义
    public Person(String name){
        this.name = name;
    }
    //alt+insert   快捷键

}
/*
 public static void main(String[] args) {
 //new 实例化了一个对象
        Person person = new Person("狂神");
        System.out.println(person.name);
    }
构造器:
1.和类名相同
2.没有返回值

作用:
    1.new 本质是在调用构造方法
    2.初始化对象的值
注意点:
    1.定义有参构造之后,如果想要使用无参构造,显示的定义一个无参的构造.

    快捷键:alt+insert

    this. 代表当前类的  =  传进来的值
 */

实例3

package oop.demo03;

public class Pet {
   public String name;
   public int age;

    public void shout(){
        System.out.println("老王叫了一声");
    }

}

/*
public static void main(String[] args) {
        //    dog 是引用变量名
        Pet dog = new Pet();
        dog.name = "老王";
        dog.age=5;
        dog.shout();
        System.out.println(dog.name);
        System.out.println(dog.age);

        Pet cat = new Pet();
        cat.name = "波斯";
        System.out.println(cat.name);

    }
 */

小总结:

package oop.demo02;

import oop.demo03.Pet;

//一个项目应该只存一个main方法
public class Application {
    public static void main(String[] args) {
        /*
        1.类与对象
             类是一个模板,抽象,对象是一个具体的实例
         2.方法
            定义 ,调用!
         3.对应的引用
            引用类型:  基本类型 (8)
              对象是通过引用来操作的:栈---->堆

         4. 属性:字段Field  成员变量
               默认初始化:
                    数字:0    0.0
                    char:   u0000
                    boolean:  false
                    引用 :   null

                修饰符  属性类型   属性名  =  属性值!
        5.对象的创建和使用
            一/  必须使用new关键字创建对象,  构造器   Person  han = new Person();
            二/  对象的属性  han.name
            三/  对象的方法  han.sleep()

         6.类:(类里面只写这两个东西)
             静态的属性  属性
             动态的行为  方法

         7.面向对象的三大特征
               封装
               继承
               多态
         */



    }

}

封装

该漏的漏,该藏得藏

“高内聚,低耦合”

高内聚:就是类的内部数据操作细节自己完成不许外部干涉

低耦合:仅暴露少量的方法给外部使用.

####　属性私有　ｇｅｔ　ｓｅｔ

封装是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。

package oop.demo04;

public class Student {
    private String name;//名字
    private int id;//学号
    private char sex;//性别
    private int age;//年龄

    //提供一些可以操作这个属性的方法
    //提供一些public的get ,set 方法
    //get 获得这个数据
    //set  给这个数据设置值
    /*
    封装的意义:
    1.提高程序的安全性,保护数据
    2.隐藏代码的实现细节
    3.统一接口
    4.提高了系统的可维护性
     */
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age > 120 || age < 0) {

            this.age = 3;
        } else {
            this.age = age;
        }
    }
}
/*

 public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("老王");
        System.out.println(s1.getName());
        s1.setAge(80);
        System.out.println(s1.getAge());
    }
 */

继承

继承图示

在这里插入图片描述

类和类的关系:继承 依赖 组合 聚合.

package oop.demo05;
//Person 类   人     : 父类

//在Java中,所有的类,都默认直接或间接的继承object类
public class Person {


    private int money = 10_0000_0000;

    public void say() {
        System.out.println("说了一句话");
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
//public 公共的  可以继承
    //protected   受保护的,优先级比default高点.
    //default   默认的
    //private  私有的  无法继承   一般用于属性上

}

/*
    public static void main(String[] args) {
        Student student = new Student();
        student.say();
        System.out.println(student.money);
       

    }
 */

package oop.demo05;
//学生  is  人    :派生类/子类

//子类继承了父类,就会拥有父类全部方法!
public class Student  extends Person{

}

super详解

super注意点
1.super调用父类的构造方法,必须在构造方法的第一个
2.super必须只能出现在子类的方法或者构造的方法中
3.super和this不能同时调用构造方法

super    vs   this:
1.代表对象不同:
    this:本身调用者这个对象
    super:代表父类对象的应用
2.前提:
    this:没有继承也可以使用
    super:只能在继承条件下才能使用
3.构造方法:
    this(); 本类的构造
    super();父类的构造!super注意点
1.super调用父类的构造方法,必须在构造方法的第一个
2.super必须只能出现在子类的方法或者构造的方法中
3.super和this不能同时调用构造方法

super    vs   this:
1.代表对象不同:
    this:本身调用者这个对象
    super:代表父类对象的应用
2.前提:
    this:没有继承也可以使用
    super:只能在继承条件下才能使用
3.构造方法:
    this(); 本类的构造
    super();父类的构造!

package oop.demo05;
//学生  is  人    :派生类/子类

//子类继承了父类,就会拥有父类全部方法!
public class Student extends Person {
    private String name = "xun";

    public Student() {
        //隐藏代码:调用了父类的无参构造
        super();//调用父类的构造器,必须要在子类构造器的第一行

        System.out.println("Student无参执行了");
    }

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

    public void test1(String name) {
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }

    public void test2() {
        print();
        this.print();
        super.print();

    }

}


package oop.demo05;
//Person 类   人     : 父类 
//私有的东西无法被继承
//在Java中,所有的类,都默认直接或间接的继承object类
public class Person {
    public Person() {
        System.out.println("Person无参执行了");
    }

    protected String name = "han";

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

}

重写

package oop.demo05;

public class A extends B{
//@Override:  重写
    @Override //注解:有功能的注释@
    public void test() {
        System.out.println("A==>TEST();");
    }
}

package oop.demo05;
//重写都是方法的重写,和属性无关
public class B {

    public  void test(){
        System.out.println("B=>test()");
    }

}


package oop;

import oop.demo05.A;
import oop.demo05.B;

public class Applic {
    //静态的方法和非静态的方法区别很大!
    //静态方法:  //方法的调用只和左边定义的数据类型有关.
    //非静态:重写
    public static void main(String[] args) {


        A a = new A();
        a.test();  //A

        //父类的引用指向了子类
        B b = new A();
        b.test(); //B
    }
}



 重写:需要有继承关系,子类重写父类的方法!
     1.方法名必须相同
     2.参数列表必须相同
     3.修饰符: 范围可以扩大:  public> protected >  default >private
     4.抛出的异常: 范围,可以被缩小,但不能被扩大;

     重写,子类的方法和父类的方法必须一致;方法体不同!


    思考:为什么要重写!
       1.父类的功能,子类不一定需要,或者不一定满足
       2.alt+insert : override;

##　多态

###　多态

在这里插入图片描述

package oop.demo06;

public class Person {

    public void run(){
        System.out.println("run");
    }
}
/*
多态注意事项:
 1.多态是方法的多态,属性没有多态
 2.父类和子类,有联系  类型转换异常! ClassCastException!
 3.存在条件: 继承关系,方法需要重写 , 父类引用,指向子类对象!
     Father f1 = new Son();

不可重写的情况,更不可以多态
    1.static  方法,属于类,它不属于实例
    2.final   常量
    3.private  私有
 */


package oop.demo06;

public class Student  extends Person{
    @Override
    public void run() {
        System.out.println("son");
    }
    public  void eat(){
        System.out.println("eat");
    }
}


package oop;

import oop.demo06.Person;
import oop.demo06.Student;

public class Applic {

    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //new Student
        //new Person

        //可以指向的引用类型就不确定了:父类的引用指向子类

        //Student能调用的方法都是自己的或者继承父类的!
        Student s1 = new Student();
        //Person父类型: 可以指向子类,但不能调用子类独有的方法!
        Person s2 = new Student();
        Object s3 = new Student();

        //对象能执行哪些方法,主要看对象左边的类型,和右边关系不大!
        ((Student) s2).eat(); //子类重写了父类的方法,执行子类的方法
      
       s1.eat();

    }
}

instanceof

判断两个类之间是否存在父子关系

它的作用是测试它左边的对象是否是它右边的类的实例

 Object object = new Student();
        System.out.println(object instanceof Student);  //true
        System.out.println(object instanceof Person);   //true
        System.out.println(object instanceof Object);   //true
        System.out.println(object instanceof Teacher);  //false
        System.out.println(object instanceof String);   //false

        System.out.println("============================================");
        Person person = new Student();
        System.out.println(person instanceof Student);  //true
        System.out.println(person instanceof Person);   //true
        System.out.println(person instanceof Object);   //true
        System.out.println(person instanceof Teacher);  //false
        //System.out.println(person instanceof String); //直接编译错误

     System.out.println("============================================");

     Student student = new Student();
        System.out.println(student instanceof Student);  //true
        System.out.println(student instanceof Person);   //true
        System.out.println(student instanceof Object);   //true
        //System.out.println(student instanceof Teacher);  //直接编译错误
        //System.out.println(student instanceof String); //直接编译错误

 public static void main(String[] args) {
        //类型之间的转换 : 父    子
        //高                  低
        Person obj = new Student();

        //student 将这个对象转换为Student类型.我们就可以使用Student类型的方法了!
        Student student = (Student) obj;
        student.go();

        //子类转换为父类,可能会丢失自己的本来的一些方法!
    }
}

/*
1.父类引用指向子类的对象
2.把子类转换为父类,向上转型;
3.把父类转换为子类,向下转型;强制转换
4.方便方法的调用,减少重复的代码
 */

static

static


package oop.demo07;

public class Student {
    private int age;             //非静态变量
    private static String name;  //静态变量

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

    public static void go() {
        System.out.println("go!go!go!");
    }

    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println(Student.name);
        System.out.println(s1.age);
        System.out.println(name);
        System.out.println("===================");
        s1.run();
        go();

    }
}
/*
运行结果
null
0
null
===================
run!run!run!
go!go!go!

 */

代码块


package oop.demo07;

public class Person {
    //2第二个执行,可以赋初始值
    //构造器是在代码块后面执行
    {
        //代码块(匿名代码块)
        System.out.println("匿名代码块");
    }

    //1第一个执行,但只在开始执行一遍
    static{
        //代码块(静态代码块)
        System.out.println("静态代码块");
    }
//3第三个执行
    public Person() {
        //构造器
        System.out.println("构造器");
    }

    public static void main(String[] args) {
        Person p1 = new Person();

        System.out.println("===================");
        Person p2 = new Person();
    }
}
/*
运行结果:
静态代码块
匿名代码块
构造器
===================
匿名代码块
构造器
 */

静态导入包

package oop.demo07;
import static java.lang.Math.PI;
import static java.lang.Math.random;
//可以静态导入包
public class Test {
    public static void main(String[] args) {
        System.out.println(PI);
        System.out.println(random());
    }
}

##　抽象类

概念

在这里插入图片描述

package oop.demo08;
//abstract 抽象类     extends:  单继承~~     但是接口可以实现多继承
public abstract class Action {
    //约束~有人帮我们实现~
    //抽象方法,只有方法名字,没有方法的实现
    public abstract void doSomething();

    //特点:1.不能new这个抽象类,只能靠子类去实现它: 约束!
    //2.有了抽象方法,一定要是在抽象类中,   抽象类中不一定有抽象方法.
    //抽象的抽象: 约束~

    //思考?   new,存在构造器吗?
           //   存在的意义  抽象出来~ 提高开发效率,提高可扩展性.
}
	

package oop.demo08;
//抽象类的所有方法,继承了他的子类,都必须要实现他的方法~ 除非~
public class A extends Action{

    @Override
    public void doSomething() {

    }
}

##　接口

在这里插入图片描述

本质：

接口的本质是契约．

作用

作用:
   1.接口是约束
   2.定义一些方法,让不同的人实现~   10----->1,十个人实现的一种接口
   3.默认的接口方法: public abstract
   4.默认的接口常量: public static final
   5.接口不能被实例化~ ,接口中没有构造方法~
   6.可以实现多个接口,通过implements
   7.必须重写接口中的方法

代码:

package oop.demo09;
//要充分理解抽象思维

//interface 定义关键字
//接口都需要实现类
public interface UserService {
    //属性~常量  public static final
    //一般不会定义常量,而是定义方法.
    int age = 99;
    public static final int old = 50;

    //接口中的所有定义其实都是抽象的  public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}


package oop.demo09;

public interface TimService {
    void timers();
}


package oop.demo09;
//抽象类是extends ~只能单继承 而接口可以继承多个

//类  可以实现接口 implements 接口
//实现了接口的类 ,就需要重写接口中的方法
//多继承~利用接口实现多继承~
public class UserServiceImpl implements UserService,TimService {

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timers() {

    }
}

内部类

概念:

在这里插入图片描述

成员内部类

package oop.demo10;

public class Outer {

    private int id = 10;
    public void out(){
        System.out.println("这是外部类方法");
    }

   public class Inner {
        public void in(){
            System.out.println("这是内部类的方法");
        }

        //可以获得外部类的私有属性~ 私有方法
        public void getID() {
            System.out.println(id);
        }
    }
}


package oop;

import oop.demo10.Outer;

public class Applic {

    public static void main(String[] args) {

        Outer outer = new Outer();
        outer.out();

        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getID();
    }
}

静态内部类

public static class Inner(){
    
}

局部内部类

package oop.demo10;

public class Outer {
    public void method() {
        //局部内部类
        class Inner {
            public void in() {
            }
        }
    }
}

###　扩展

package oop.demo10;

public class Outer {


//
    }
    //一个java类中可以有多个class类,但是只能有一个public class类
class A{

    }

没有名字的类:

package oop.demo10;

public class Test {
    public static void main(String[] args) {
        //没有名字去初始化类 , 别用将实例保存到变量中
        new Apple().eat();

        new Apple.UserService(){

            @Override
            public void hello(String name) {
              
            }
        };
    }
}
class Apple{
    public void eat(){
        System.out.println("1");
    }

    interface UserService{

        void hello(String name);
    }
}
     Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getID();
    }
}

静态内部类

public static class Inner(){
    
}

局部内部类

package oop.demo10;

public class Outer {
    public void method() {
        //局部内部类
        class Inner {
            public void in() {
            }
        }
    }
}

###　扩展

package oop.demo10;

public class Outer {


//
    }
    //一个java类中可以有多个class类,但是只能有一个public class类
class A{

    }

没有名字的类:

package oop.demo10;

public class Test {
    public static void main(String[] args) {
        //没有名字去初始化类 , 别用将实例保存到变量中
        new Apple().eat();

        new Apple.UserService(){

            @Override
            public void hello(String name) {
              
            }
        };
    }
}
class Apple{
    public void eat(){
        System.out.println("1");
    }

    interface UserService{

        void hello(String name);
    }
}
_/~淡淡的青春ら纯纯的爱
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ES6 Class中实现私有属性的一些方法总结
01-19
私有属性 私有属性是面向对象编程（OOP）中非常常见的一个特性，一般满足以下的特点： 能被class内部的不同方法访问，但不能在类外部被访问； 子类不能继承父类的私有属性。 备胎Class 时间回到四年前，2015年6月，ES6发布成为标准，为了纪念这个历史性时刻，这个标准又被称为ES2015，至此，JavaScript中的class从备胎中转正。在这之前，class一直作为JS的关键字，雪藏不见天日。 class被认为是JS的一种语法糖，它为JavaScript带来了用面向对象的思想描述一个实体的能力。但似乎还远远不够，class的能力远没满足JS开发者们的期待。于是，TC39的
ES6 class静态属性 静态方法 私有方法 私有属性 实例属性 实例方法 静态私有属性 静态私有方法等,继承
u013400314的博客
06-27 855
ES6 class静态属性 静态方法 私有方法 私有属性 实例属性 实例方法 静态私有属性 静态私有方法等
Javaoop笔记（全套学习笔记）
白羊的博客
03-28 449
一.继承 1.重写方法 1.1 重写方法和被重写方法必须具有相同的方法名 1.2 重写方法和被重写方法必须具有相同的参数列表 1.3 重写方法的返回值类型必须和被重写方法的返回值类型相同或是其子类 1.4 重写方法不能缩小被重写方法的访问权限 2.super的作用和使用 2.1 super必须出现在子类(子类的方法和构造方法)中，而不是在其他位置。 2.2 可以访问父类的成员，如父类的...
【Java】综合案例：学生信息管理（v0.1）
实施工程师从入门到放弃
09-20 141
介绍： 这个是只有专业学生信息，入门自己写，不容易，记录下 一个学生类，一个专业类，一个管理类作为主方法 主方法 public class StudentManage { public static void main(String[] args) { // TODO Auto-generated method stub Major m1=new Major("计算机科学与技术","J0001","4年"); Student s1=new Student("张三","S01","男",18
JAVA面向对象oop基础笔记
ypf3442354429的博客
04-23 529
第一章 1.属性---是对象具有的各种特征 2.方法---是对象执行的操作和行为 3.类---具有相同属性和方法的一组对象的集合 4.类是对象的抽象,对象是类的具体 (动物类-->狮子对象,老虎对象...) (植物类-->向日葵对象,牡丹花对象...) 5.对象是摸得到看得见的实品,是开发的时候要考虑的。java是面向对象编程语言 6.对象的使用步骤 (1)创建对象,通过关键词new (2)引用对象,使用"." 7.类的方法 修饰单词 返回值类型 方法名(){}.
Java面向对象编程学习笔记.pdf
12-01
Java面向对象编程学习笔记.pdf
JAVA面向对象编程学习笔记.pdf
09-30
JAVA面向对象编程学习笔记.pdf
Python的面向对象编程方式学习笔记
09-21
Python深度具备面向对象编程语言所应有的特性,这里我们以类和方法为主,来整理一下Python的面向对象编程方式学习笔记:
C#中面向对象编程机制之多态学习笔记
12-31
我的理解是：同一个操作，作用于不同的对象时，会有不同的结果，即同一个方法根据需要，作用于不同的对象时，会有不同的实现。 C#的多态包括：接口多态，继承多态。 其中继承多态又包括通过虚拟方法实现的多态和通过...
java基础03-面向对象
最新发布
quzhiyuan9的博客
07-20 534
面向过程（Procedural Programming）和面向对象（Object-Oriented Programming，简称 OOP）是两种不同的编程范式。面向对象是一种以对象为中心的编程思想。它将程序视为对象的集合，每个对象都有自己的状态（属性）和行为（方法）。在面向对象编程中，数据和操作是紧密相关的，并通过封装、继承和多态等机制实现代码的组织和复用。主要特点包括：1.以对象为核心：程序由多个相互交互的对象组成，每个对象都有自己的属性和方法。
java面向对象
m0_51779342的博客
09-10 3742
万物皆对象。面向对象，是一种编程思想，是把一个整体的事物按照各个功能来进行划分。在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算机事件的设计思想。 它区别于面向过程思想，强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现。
Java面向对象
qq_43599841的博客
09-21 1220
Java面向对象
如何在ES6的class上实现私有属性
追风Programer的博客
04-04 1198
如何在ES6的class上实现私有属性
【Java基础篇】面向对象(Object Oriented)
输入技术、输出想法
08-24 1931
面向对象(Object Oriented）1. 面向对象概念1.1 什么事面向对象1.2 理解面向对象1.3 面向对象的特点1.4 面向对象开发设计,特征2. 类与对象2.1 什么是类2.2 类与对象的关系3. 类的定义4. 成员变量与局部变量的区别4.1 成员变量4.2 局部变量4.3 成员变量初始化5. 创建对象,使用对象6. 对象内存结构6.1 对象的产生6.2 对象的生命周期7. 匿名对象 1. 面向对象概念 1.1 什么事面向对象 面向对象(Object Oriented)是一种思想，90年代以
ES6 入门教程 22 Class 的基本语法 22.9 静态属性 & 22.10 私有方法和私有属性
谢谢你们的关注
11-23 928
ES6 入门教程 22 Class 的基本语法 22.9 静态属性 & 22.10 私有方法和私有属性
请你设计一下ES6中 class 类实现私有属性
qq_37833745的博客
08-18 1223
为什么会出现class 其实，学过java的小伙伴一定对class熟悉不过了。那为什么JS里面还要引入class呢？ 在 es6 之前，虽然 JS 和 Java 同样都是 OOP （面向对象）语言，但是在 JS 中，只有对象而没有类的概念。 es6 中 class 的出现拉近了 JS 和传统 OOP 语言的距离。但是，它仅仅是一个语法糖罢了，不能实现传统 OOP 语言一样的功能。在其中，比较大的一个痛点就是私有属性问题。 何为私有属性？ 私有属性是面向对象编程（OOP）中非常...
Java——面向对象
m0_59800431的博客
03-01 1123
主要介绍了什么是面向对象、类和对象的创建、构造器详解、创建对象内存分析、封装、继承、多态等内容
aop面向切面编程学习笔记
05-11
AOP（Aspect-Oriented Programming）面向切面编程是一种编程思想，它能够使我们将通用的功能模块与业务模块分离开来，从而使我们的代码更易于维护和扩展。此外，它还能够帮助我们处理一些横切问题，如日志记录、事务...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值