面向对象实操

最新推荐文章于 2024-05-30 18:09:33 发布
最新推荐文章于 2024-05-30 18:09:33 发布
阅读量91 收藏
点赞数
分类专栏： Scala 文章标签： scala
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45052608/article/details/116538319
版权

一、scala包

面向对象编程，可以建立scala包来管理类和对象。同名的类放到不同包就可以加以区分；类很多时，不同类可以放到一个包中进行管理，相当于把多个类进行了归纳。

  1. 包定义：package 包名
  2. 包命名规则：字母、数字、下划线，但不能以数字开头。也不能包含关键字。用圆点实现不同级别包的命名
  3. 包管理：
    每个源文件一个包，包名用圆点分隔以表示层级关系；(eg：com.test.byy_1)
    每个源文件多个包，通过嵌套关系表示包的层级关系，子包可以直接调用父包内容，无需导包
    eg：
package com{
	package test{
		package byy_1{
			
		}
	}
}
  1. 包对象：package object 包名，包对象一般定义在包底下的package.scala文件中。每个包可以定义与它同名的包对象，包对象中的成员可以被这个包中的所有类和对象访问。
  2. 类和对象
    class 类名：scala中类可以有参数，类是对象的抽象，不占用空间，一个源文件可以有多个类；
    object 对象名：对象是实例，占用空间。
package chapter06

//定义类
class Student{
	//定义属性
	private var name:String="alice" //private代表私有属性，变量前不加标识符默认为共有属性
	var age:Int= _ //下划线代表默认值为0
	var sex:String= _ //下划线代表默认值为null
}

//定义对象
object Test_Class{
	def main(args:Array[String]):Unit={
		//用关键字new来实例化类
		val studert = new Student()
	//	student.name //error，私有属性，访问不到
		println(student.age)
		println(student.sex)
		student.sex="female"
		println(student.sex)
	}
}
0
null
female

二、封装

封装指的是把抽象的数据与数据操作封装起来，程序的其他部分只有通过被授权的操作才能操作数据。

访问权限
  1. private：私有权限，只有类的内部和伴生对象可用
  2. protected：受保护的权限，只有同类子类可以访问，同包无法访问
  3. private[包名]：增加包访问权限，包下的其他类也可访问
主构造器与辅助构造器

辅助构造器的名称为this,每个辅助构造器都必须以一个对先前已经定义的其他构造器调用先开始

  1. 主构造器有参数

参数前没有修饰符时，此时的属性为类的局部变量而非属性，不能直接被调用，此时就需要在类中定义一个方法，从而调用这个方法

object Main {
  def main(args:Array[String])
  {
    val student1 = new Student(name="cindy",age=20) //调用类及其方法
  }
		
}
//类
class Student(name:String,age:Int){ //参数为变量
	println(s"${name}今年${age}岁") //需定义调用参数的方法
}
cindy今年20岁

参数前有修饰符(var、val)时，相当于属性，就无需在类中单独定义属性了，参数可以直接被调用(推荐使用，灵活简单)
主构造器有修饰符的参数，定义辅助构造器时参数无需修饰符

object Main {
  def main(args:Array[String]): Unit=
  {
	  val student1 = new student("alice",18) //调用主构造器，参数直接赋值
	  student1.school="北大"
	  println(s"${student1.school}的${student1.name}今年${student1.age}岁") //参数赋值后调用
	  val student2 = new student("cindy",20,"清华") //调用第一个辅助构造器（主构造器也被调用）
  }
		
}

class student(var name:String,var age:Int){ //参数相当于可变属性
	var school:String= _ //单独定义属性
    println(s"${school}的${name}今年${age}岁")
	
	def this(name:String,age:Int,school:String){ //辅助构造器使用主构造器的所有属性为参数
		this(name,age) //调用主构造器
		this.school=school //将主构造器的属性定义为辅助构造器的参数
		println(s"${age}岁的${name}在${school}上学")
	}
}
  1. 主构造器无参数
object Main {
  def main(args:Array[String]): Unit=
  {
	  val student1 = new student //调用主构造器
	  //给主构造器的参数重新赋值后输出
	  student1.name="cindy"
	  student1.age=20
	  println(s"${student1.name}${student1.age}岁")
	  val student2 = new student("cindy") //调用第一个辅助构造器（主构造器也被调用）
	  val student3 = new student("cindy",16) //调用第二个辅助构造器（主构造器和第一个辅助构造器也被调用）
  }
		
}

class student{ //类无参数，需要单独定义属性
	var name:String="Alice" //可变属性
	var age:Int=18 //可变属性
    println(s"${name}今年${age}岁")
	
	def this(name:String){
		this() //调用主构造器
		this.name=name
		println(s"${name}")
	}
	
	def this(name:String,age:Int){
		this(name:String) //调用第一个辅助构造器
		this.age=age
		println(s"${age}的${name}")
	}
}
Alice今年18岁
cindy20岁

Alice今年18岁
cindy

Alice今年18岁
cindy
16的cindy

三、类的继承

  1. 子类继承父类的属性(私有属性除外)和方法
  2. 继承类：class 子类名 extends 父类名{}
  3. 子类中的方法重写：override 父类方法
  4. 方法调用：对象名.方法()
  5. 多态：一个接口的不同实现，即把一个实现类的对象实例传给接口。接口通过对不同类的引用，来调用不同类的实现
object Main {
  def main(args:Array[String]): Unit=
  {
	  val student1 = new Student("alice",18) //调用子类主构造器前，先调用父类主构造器
	  student1.printlninfo() //固定实现子类
	  val student2 = new Student("alice",18,"femal") //调用子类辅助构造器前，先调用父类、子类主构造器
	  student2.printlninfo() //固定实现子类的辅助构造器
	  println("======")
	  val person1 = new Person("bob",21)
	  def personprintinfo(a:Person):Unit={ //定义动态绑定类的方法，让同一接口实现不同类(可以理解为：方法的参数就是要传入的类，但是参数的类型一定要是父类或同类)
		a.printlninfo()
	  }
	  personprintinfo(student1)
	  personprintinfo(person1)
  }		
}
//父类
class Person(var name:String){
	var age:Int= _
	println(s"1.父类主构造器调用")
	def this(name:String,age:Int){
		this(name)
		this.age=age
		println(s"2.父类辅助构造器调用")
	}
	def printlninfo():Unit={
		println(s"${name} ${age}")
	}
}
//子类
class Student(name:String,age:Int) extends Person(name){ //子类age直接继承父类属性age，所以不用单独给参数赋值
	var sex:String= _
	println(s"3.子类主构造器调用")
	def this(name:String,age:Int,sex:String){
		this(name,age)
		this.sex=sex
		println(s"4.子类辅助构造器调用")
	}
	override def printlninfo():Unit={ //重写方法
		println(s"${name} ${age} ${sex}")
	}
}
1.父类主构造器调用
3.子类主构造器调用
alice 18 null
1.父类主构造器调用
3.子类主构造器调用
4.子类辅助构造器调用
alice 18 femal
======
1.父类主构造器调用
2.父类辅助构造器调用
alice 18 null
bob 21

四、抽象类

抽象类就是包含非具体实现的方法和属性的不确定的类。
抽象类一般要用实例化子类去重写属性和方法，从而实现抽象类。
我们也可以在对象中直接用new关键字定义一个匿名子类来实现抽象类

  1. 抽象属性：没有初始值的属性
  2. 抽象方法：没有方法体的方法
  3. 子类实现规则
    抽象属性：var定义的属性直接重写即可；val定义的属性需要加override进行重写
    非抽象属性：var定义的属性直接给变量赋新值就好；val定义的属性需要加override
    抽象方法：override可加可不加
    非抽象方法：要加override
  4. 也可以用匿名子类实例化抽象类

非匿名子类实例化抽象类

object Main {
  def main(args:Array[String])
  {
	//调用子类，抽象类不能直接被调用
	val student1=new Student
	student1.printinfo()
	student1.printinfo1()
	println("=======")
	val student2=new Student2
	student2.printinfo()
	student2.printinfo1()
  }
		
}

//抽象父类
abstract class Person{
	//抽象属性
	var name:String
	val age:Int
	//非抽象属性
	var sex:String="male"
	val school:String="清华"
	//非抽象方法
	def printinfo():Unit={
		println(s"person: ${name} ${age}")
	}
	//抽象方法
	def printinfo1():Unit
}

//实现子类1
class Student extends Person{
	//实现抽象属性
	var name:String="alice" //var定义的属性可变，所以不需要加override
	override val age:Int=19 //val定义的属性需要加override
	//重写非抽象方法
	override def printinfo():Unit={
		println(s"student: ${name} ${sex} ${age}")
	}
	//实现抽象方法
	override def printinfo1():Unit={
		println(s"student: ${name} ${age}")
	}
}

//实现子类2
class Student2 extends Person{
	//实现抽象属性
	var name:String="alice" //var定义的属性可变，所以不需要加override
	override val age:Int=19 //val定义的属性需要加override
	//重写抽象属性
	sex="female" //var变量直接赋值
	override val school="北大" //val变量重写
	//重写非抽象方法
	override def printinfo():Unit={
		println(s"student: ${name} ${sex} ${age} ${school}")
	}
	//实现抽象方法
	override def printinfo1():Unit={
		println(s"student: ${name} ${age} ${school}")
	}
}
student: alice male 19
student: alice 19
========
student: alice female 19 北大
student: alice 19 北大

匿名子类实例化抽象类

object Main {
  def main(args:Array[String]):Unit=
  {
	val person:Person = new Person{ //匿名子类定义
		var name:String="alice"
		override val age:Int=18
		override def printinfo1():Unit={
			println(s"${name} ${age} ${sex} ${school}")
		}
	}
	person.printinfo1()
  }
		
}

//抽象父类
abstract class Person{
	//抽象属性
	var name:String
	val age:Int
	//非抽象属性
	var sex:String="male"
	val school:String="清华"
	//非抽象方法
	def printinfo():Unit={
		println(s"person: ${name} ${age}")
	}
	//抽象方法
	def printinfo1():Unit
}
alice 18 male 清华

五、伴生对象&伴生类

伴生对象用object声明，伴生对象的属性和方法是静态的，且可以直接通过伴生对象名调用，也可以直接被伴生类调用(包括私有的)；
伴生对象对应的类为伴生类，伴生对象与伴生类的名字一样
伴生对象中定义的apply()方法，在调用时可以省略方法名

eg：调用伴生类实现功能，伴生类调用伴生对象的静态属性

object Test {
  def main(args:Array[String]):Unit=
  {
	val student = new Person(name="alice",age=18) //伴生类重定义
    Person.school="北大" //伴生对象Person调用其属性，并重新赋值
	student.pri() //伴生类的方法调用
  }
		
}

//伴生类
class Person(val name:String,val age:Int){
	def pri(){
		println(s"${name} ${age} ${Person.school}") //伴生类调用伴生对象的属性school
	}
}

//伴生对象，定义静态属性school
object Person{
	var school:String="清华"
}
alice 18 北大

eg：调用伴生对象实现功能，不调用伴生类：类的属性私有化，不能直接被调用；此时先建立伴生对象调用伴生类的私有属性，再调用伴生对象实现功能

object Test {
  def main(args:Array[String]):Unit=
  {
	val student = Person.newpri(name="alice",age=18) //伴生对象中伴生类的实例化方法调用
	val student = Person(name="alice",age=18) //apply方法调用
    Person.school="北大" //伴生对象Person调用其属性，并重新赋值
	student.pri() //伴生类的方法调用
  }
		
}

//伴生类
class Person private(val name:String,val age:Int){
	def pri(){
		println(s"${name} ${age} ${Person.school}") //伴生类调用伴生对象的属性school
	}
}

//伴生对象，定义静态属性school
object Person{
	var school:String="清华"
	//定义伴生类的实例化方法
	def newpri(name:String,age:Int):Person=new Person(name,age) //方法newpri可以使用类Person的属性
	//apply方法
	def apply(name:String,age:Int):Person=new Person(name,age) //方法newpri可以使用类Person的属性
}
alice 18 北大

六、特质trait

scala特质既可以代替接口，又可以补充类的单继承

trait 特质名{
	trait体
}
  1. 当多个类具有相同特质时，就可以把这些特质独立出来，用trait声明，这样也方便使用
  2. 类和特质的关系也是类继承特质。常说的一个类具有特质，指的是这个类满足特质的所有要素。一个类可以继承多个特质，因为一个类需要的元素可以存在于不同的特质中（比如一个子类只能有一个父类，但是这个子类需要的属性，其父类不一定都有。而在每个需要这些属性的子类中分别定义的话，又要重复很多次。像这样的多个类具有相同特质的情况，为了方便操作使用，就可以把这些特质独立出来，用trait声明。）
  3. 特质中可以有抽象和非抽象的属性与方法
  4. super:子类中在重写方法时，可以用super调用父类或trait中的方法，然后再定义新的输出。在方法名有重复时，优先调用最后一个出现的trait中的方法。也可以用super[类名或特质名] 来调用指定父类或特质的方法
  5. 特质与类的区别：
    特质更灵活，可以实现多继承，优先使用
    特质不能带参，类可以带参，需要使用参数的时候优先使用类
  6. 用法
    无父类 class 类名 extends trait1 with trait2…
    有父类 class 类名 extends 父类名 with trait1 with trait2…
    特质继承 trait1 extends trait2 with trait3 …

eg：既定特质：直接输出子类

object Test {
  def main(args:Array[String]):Unit=
  {
	val student = new Student
	student.pri()
	student.paly()
	student.dating()
	student.eat()
  }
		
}

//父类
abstract class Person{
	val name:String="alice"
	val age:Int
	def pri():Unit={
		println(s"${name} ${age}")
	}
}

//特质
trait Young{
	val name:String
	val age=18
	def paly():Unit={
		println(s"${name} is playing")
	}
	def dating():Unit
}

//子类
class Student() extends Person() with Young{
    //冲突属性重写
    override val name:String="cindy"
    override val age:Int=20
	//抽象方法实例
	override def dating():Unit={
		println(s"${name} ${age} is dating")
	}
	//重写父类方法
	override def pri():Unit={
		super.pri() //pri()方法调用
		println(s"${name} ${age} is a student") //方法重写
	}
	//新建方法
	def eat():Unit={
		println(s"${name} is eating")
	}
}
cindy 20
cindy 20 is a student
cindy is playing
cindy 20 is dating
cindy is eating

eg：动态混入特质：调用子类时，特定情况需要输出特质时再混入，否则都是按照子类输出

object Test {
  def main(args:Array[String]):Unit=
  {
	val student = new Student with Talient{
		override def sing():Unit={
			println(s"${name} ${age} likes singing")
		}
		override def dance():Unit={
			println(s"${name} ${age} likes dancing")
		}
		override def play():Unit={
			super.play() //调用trait中的方法，优先调用最后一个出现的trait中的方法
			println(s"${age}岁的${name} is playing")
		}
		override def pri():Unit={ //重写pri()方法
			super.pri() //调用父类和trait中的方法，也优先调用最后一个出现的trait中的方法
			println(s"${age}岁的${name}")
		}
	}
	student.pri()
	student.play()
	student.dating()
	student.eat()
	student.sing()
	student.dance()
  }
		
}

//父类
abstract class Person{
	val name:String="alice"
	val age:Int
	def pri():Unit={
		println(s"${name} ${age}")
	}
}

//特质
trait Young{
	val name:String
	val age=18
	def play():Unit={
		println(s"${name} is playing")
	}
	def dating():Unit
}

//特质2
trait Talient{
	def sing():Unit
	def dance():Unit
	def play():Unit={
		println("playing")
	}
	def pri():Unit={
		println("pri")
	}
}

//子类
class Student() extends Person() with Young{
    //冲突属性重写
    override val name:String="cindy"
    override val age:Int=20
	//抽象方法实例
	override def dating():Unit={
		println(s"${name} ${age} is dating")
	}
	//新建方法
	def eat():Unit={
		println(s"${name} is eating")
	}
}
pri
20岁的cindy
playing
20岁的cindy is playing
cindy 20 is dating
cindy is eating
cindy 20 likes singing
cindy 20 likes dancing
Ayanha
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Scala——主构造器、辅助构造器与私有构造器
Captain72的博客
12-20 1893
Scala学习笔记——主构造器、辅助构造器、私有构造器本篇为Scala学习笔记，欢迎转载，请表明出处： 辅助构造器 主构造器 私有构造器 辅助构造器(Auxiliary Constructor)**1. 辅助构造器的名称为this** **2. 每个辅助构造器都必须以一个对先前已定义的其他辅助构造器或主构造器的调用开始** class Student { private var name =
面向对象设计
qq_35097836的博客
05-13 419
面向对象的基本概念 面向对象设程序设计（Object Oriented Programming），即OOP。其思想是将事物抽象为对象，对象具有自己的状态和行为，实际就是通过对象对消息的反应来完成一定的任务。 面向对象中的两个重点对象和类 类 类是一种复合数据类型。它封装了类对象的变量和方法，是这一类对象的原型。 对象 现实生活中任何物体都是对象，在程序中对象是类的实例产物。 ...
Scala学习笔记——主构造器、辅助构造器与私有构造器
Machine Learning with Tutors
07-14 5331
上述代码声明并初始化了不可变字段name和color，并且这两个字段都是对象私有的。也就是说，类的方法，只能访问到当前对象的字段。想要让主构造器变成私有构造器，只需要加上private关键字即可。这样做之后，就必须使用辅助构造器来构造Dog对象了。
构造器
weixin_45656377的博客
11-30 133
定义：构造器与其他的方法有一个重要的不同。构造器总是伴随着 new 操作符的执行被调用，而不能对一个已经存在的对象调用构造器来达到重新设置实例域的目的。jdk会根据new后面的构造方法名找到类分类内存空间然后创建实例 特点： 构造器与类同名 •每个类可以有一个以上的构造器 •构造器可以有 0 个、1 个或多个参数 •构造器没有返回值 •构造器总是伴随着 new 操作一起调用 ...
Python基础篇：面向对象【案例实操】
五包辣条的博客
06-21 2772
面向对象编程对初学者来说不难理解但很难应用，虽然我们为大家总结过面向对象的三步走方法（定义类、创建对象、给对象发消息），但是说起来容易做起来难。大量的编程练习和阅读优质的代码可能是这个阶段最能够帮助到大家的两件事情。 接下来我们还是通过经典的案例来剖析面向对象编程的知识，同时也通过这些案例为大家讲解如何运用之前学过的Python知识。...
Java基础之面向对象详细讲解——实操
getture的博客
12-06 193
本实操对面向对象以及构造方法进行理解掌握，而不是进行大难度的训练，如果想要进行更复杂的操作也可以结合各种循环、判断来进行更好的理解 题目： 英雄联盟中有盖伦、伊芙琳两个英雄，魔沼蛙一个野怪 盖伦属性：名字，称号，血量，技能qwer 行为：分别释放qwer技能，让野怪掉血 伊芙琳属性：名字，称号，血量，蓝量，技能qwer 行为：分别释放qwer技能，让野怪掉血 魔沼蛙属性：名字，称号，血量 行为：攻击，让英雄掉血 现在进行这三个对现象的建立，并且进行三个对象之间的动作实操， 输出三者之间进行的动作，盖
Python基础篇：面向对象【案例实操】_python面向对象的实例练习 csdn(2)
2401_84585372的博客
05-02 688
简单起见，我们的扑克只有52张牌（没有大小王），游戏需要将52张牌发到4个玩家的手上，每个玩家手上有13张牌，按照黑桃、红心、草花、方块的顺序和点数从小到大排列，暂时不实现其他的功能。Python所有方向路线就是把Python常用的技术点做整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。成为一个Python程序员专家或许需要花费数年时间，但是打下坚实的基础只要几周就可以，如果你按照我提供的学习路线以及资料有意识地去实践，你就有很大可能成功！
面向对象程序设计教程
quqizui的博客
04-28 931
面向对象程序设计教程（c#版）（本文只是本人在学习有关教程时所作的一个笔记，仅供参考） 前言 本文只用于学习交流使用，如其中有用词不当或代码错误的地方，还望指正。本文使用教材及参考资料包括但不限于面向对象程序设计教程（c#版）刘瑞新等编著。 面向对象程序设计是一种程序设计架构，同时也是程序开发的一种方法，学习本课程之前希望大家能够有一定的编程语言基础，本文中所有程序编译环境均为Visual Studio 2022。 类与对象 1、对象是什么？类是什么？ 对象可不是买象棋就能有的，也不是轻易就能懂得！！！当然
C#演练：一步一步教你如何编写面向对象代码
C#开发
11-19 618
之前写过一篇文章：C#一步一步教你如何去写面向对象代码 今天再次演练，让大家尽可能熟悉并熟练面向对象代码的编写思路和方法。 今天以汉服的“形制”为例子，演练怎么编写汉服的面向对象代码。本文出现的中文编码是为了让您看起来方便，您实际业务编写时不宜使用中文。 一、构思 您的构思，可以来自于UML图，也可以来自于纸张随意绘制，也可以来自你的思维灵感图，看您喜欢，层次关系您需要确定清楚。 下图是关于“汉服形制”的思维导图。 1.形制的继承关系如上图，树形结构清晰，就不再废话了。 2.每个形制.
Java面向对象初级实操项目-输入大作战
08-07
1.此为实操项目，有利于初学者练习 2.有具体的解题思路可供草考
PHP面向对象程序设计之对象的遍历操作示例
10-16
主要介绍了PHP面向对象程序设计之对象的遍历操作,结合具体实例形式分析了php面向对象程序设计中对象属性遍历的相关操作技巧与注意事项,需要的朋友可以参考下
java面向对象的实例
11-09
java面向对象的实例，代码java的三大特性，封装，继承，多态以及关键字的运用！
客户管理系统crm.zip
07-09
java面向对象刚学完的，可以用该项目（客户管理系统）实操，里面包含增删改查功能，并且主要包含对数组的使用。
C++面向对象多线程编程(多操作系统版)
01-31
本书基于windows和unix like(unix及linux等类unix)，从面向对象的角度深入讨论了多线程实现以及应该注意的问题，确实是一本初学c++或正想向多线程或者说跨平台方向发展的程序员学习的好书。
Spark基础：Scala内建控制结构
IT深耕十余载，大道之简
05-29 617
在Scala中，控制结构是编程的基础，它们允许你根据条件执行不同的代码块，或者重复执行某些代码块。Scala的for循环非常强大，可以遍历集合、数组、列表等，并支持多种模式，包括传统的C-style for循环和更强大的for推导式（for comprehension）。Scala的模式匹配功能强大且灵活，它允许你根据输入的值匹配不同的模式，并执行相应的代码块。这在处理复杂的数据结构时特别有用。等操作中，你可能需要根据数据的某些属性来执行不同的操作，这时就需要使用到条件语句和循环结构。
Spark大数据处理 掌握Scala运算符
IT深耕十余载，大道之简
05-30 763
在Spark大数据处理中，Scala的运算符是编程的基础。掌握这些运算符的用法和特性，可以帮助你更有效地编写高效、可读的Spark代码。同时，Spark的DataFrame和Dataset API也提供了许多内置的函数和方法，用于更复杂的数据处理和分析任务。
Scala 柯里化、sortBy方法
最新发布
weixin_63548495的博客
05-30 373
柯里化，sortBy方法，隐式参数，隐式转换
Scala学习笔记7: 对象
Taerge0110的博客
05-29 1086
在Scala中, 伴生对象 (Companion Object) 是一个与类同名的对象, 用于扩展类的功能并提供类级别的操作;通过这种方式, 你可以灵活地扩展类或特质的对象, 使其具有更多的功能和行为, 同时保持原始类或特质的不变性;通过伴生对象, 你可以在Scala中实现类级别的操作和共享的功能, 提供高代码的可维护性和灵活性;通过扩展类或特质的对象, 可以在不修改原始类或特质的情况下, 为其添加额外的功能或行为;在Scala中, 要扩展类或特质的对象, 可以使用匿名类或匿名特质的方式来实现;
大数据应用开发java 初级实操
11-17
1. Java基础知识：包括Java语法、面向对象编程、集合框架等。 2. Hadoop基础知识：包括Hadoop的安装、配置、HDFS文件系统、MapReduce编程等。 3. Hive基础知识：包括Hive的安装、配置、HiveQL语言、Hive与Hadoop的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值