Scala基础教程--07--继承与抽象类

最新推荐文章于 2024-05-06 12:52:54 发布
最新推荐文章于 2024-05-06 12:52:54 发布
阅读量660 收藏 1
点赞数
分类专栏： java spark 文章标签： scala java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kc44601/article/details/124603965
版权
java 同时被 2 个专栏收录
32 篇文章 1 订阅
订阅专栏
spark
20 篇文章 1 订阅
订阅专栏

Scala第七章节

章节目标

  1. 掌握继承和抽象类相关知识点
  2. 掌握匿名内部类的用法
  3. 了解类型转换的内容
  4. 掌握动物类案例

1. 继承

1.1 概述

实际开发中, 我们发现好多类中的内容是相似的(例如: 相似的属性和行为), 每次写很麻烦. 于是我们可以把这些相似的内容提取出来单独的放到一个类中(父类), 然后让那多个类(子类)和这个类(父类)产生一个关系, 从而实现子类可以访问父类的内容, 这个关系就叫: 继承.

因为scala语言是支持面向对象编程的，我们也可以使用scala来实现继承，通过继承来减少重复代码。

1.2 语法
  • scala中使用extends关键字来实现继承
  • 可以在子类中定义父类中没有的字段和方法，或者重写父类的方法
  • 类和单例对象都可以有父类

语法

class/object A类 extends B类 {	
    ..
}

叫法

  • 上述格式中, A类称之为: 子类, 派生类.
  • B类称之为: 父类, 超类, 基类.
1.3 类继承

需求

已知学生类(Student)和老师类(Teacher), 他们都有姓名和年龄(属性), 都要吃饭(行为), 请用所学, 模拟该需求.

  • 方式一: 非继承版.
object ClassDemo01 {
  //1. 定义老师类.
  class Teacher{
    var name = ""
    var age = 0

    def eat() = println("老师喝牛肉汤!...")
  }
  //2. 定义学生类.
  class Student{
    var name = ""
    var age = 0

    def eat() = println("学生吃牛肉!...")
  }

  //main方法, 程序的主入口
  def main(args: Array[String]): Unit = {
    //3. 测试老师类.
    //3.1 创建对象.
    val t = new Teacher
    //3.2 给属性赋值
    t.name = "刘老师"
    t.age = 32
    //3.3 打印属性值.
    println(t.name, t.age)
    //3.4 调用方法
    t.eat()
    println("-" * 15)

    //4. 测试学生类.
    val s = new Student
    s.name = "张三"
    s.age = 21
    println(s.name, s.age)
    s.eat()
  }
}
  • 方式二: 继承版
object ClassDemo02 {
  //1. 定义人类.
  class Person {
    var name = ""
    var age = 0

    def eat() = println("人要吃饭!...")
  }
  //2. 定义老师类.
  class Teacher extends Person
  //3. 定义学生类.
  class Student extends Person

  def main(args: Array[String]): Unit = {
    //4. 测试老师类.
    val t = new Teacher
    t.name = "刘老师"
    t.age = 32
    println(t.name, t.age)
    t.eat()
    println("-" * 15)
    //5. 测试学生类.
    val s = new Student
    s.name = "张三"
    s.age = 23
    println(s.name, s.age)
    s.eat()
  }
}
1.4 单例对象继承

在Scala中, 单例对象也是可以继承类的.

需求

定义Person类(成员变量: 姓名, 成员方法: sayHello()), 定义单例对象Student继承自Person, 然后测试.

object ClassDemo03 {
  //1. 定义Person类.
  class Person {
    var name = ""

    def sayHello() = println("Hello, Scala!..")
  }
  //2. 定义单例对象Student, 继承Person.
  object Student extends Person

  //main方法, 程序的主入口
  def main(args: Array[String]): Unit = {
    //3. 测试Student中的成员.
    Student.name = "张三"
    println(Student.name)
    Student.sayHello()
  }
}
1.5 方法重写
1.5.1 概述

子类中出现和父类一模一样的方法时, 称为方法重写. Scala代码中可以在子类中使用override来重写父类的成员，也可以使用super来引用父类的成员.

1.5.2 注意事项

  • 子类要重写父类中的某一个方法，该方法必须要使用override关键字来修饰

  • 可以使用override来重写一个val字段.

    注意: 父类用var修饰的变量, 子类不能重写.

  • 使用super关键字来访问父类的成员方法

1.5.3 示例

需求

定义Person类, 属性(姓名, 年龄), 有一个sayHello()方法.

然后定义Student类继承Person类, 重写Person类中的字段和方法, 并测试.

参考代码

object ClassDemo04 {
  //1. 定义父类Person.
  class Person {
    var name = "张三"
    val age = 23

    def sayHello() = println("Hello, Person!...")
  }
  //2. 定义子类Student, 继承Person.
  class Student extends Person{
    //override var name = "李四"    //这样写会报错, 子类不能重写父类用var修饰的变量.
    override val age = 24

    override def sayHello() = {
      //通过super调用父类的成员.
      super.sayHello()
      println("Hello, Student!...")
    }
  }
  //程序的入口.
  def main(args: Array[String]): Unit = {
    //3. 创建学生类型的对象, 然后测试.
    val s = new Student
    println(s.name, s.age)
    s.sayHello()
  }
}

2. 类型判断

有时候，我们设计的程序，要根据变量的类型来执行对应的逻辑, 如下图:

在这里插入图片描述

在scala中，如何来进行类型判断呢？

有两种方式：

  • isInstanceOf
  • getClass/classOf
2.1 isInstanceOf, asInstanceOf

概述

  • isInstanceOf: 判断对象是否为指定类的对象
  • asInstanceOf: 将对象转换为指定类型

格式

// 判断对象是否为指定类型
val trueOrFalse:Boolean = 对象.isInstanceOf[类型]

// 将对象转换为指定类型
val 变量 = 对象.asInstanceOf[类型]

示例代码:

​ val trueOrFalse = p.isInstanceOf[Student]

​ val s = p.asInstanceOf[Student]

2.2 案例

需求

  • 定义一个Person类
  • 定义一个Student类继承自Person类, 该类有一个sayHello()方法.
  • 创建一个Student类对象, 并指定它的类型为Person类型
  • 判断该对象是否为Student类型，如果是，将其转换为Student类型并调用sayHello()方法.

参考代码

object ClassDemo05 {
  //1. 定义一个Person类.
  class Person

  //2. 定义一个Student类, 继承Person.
  class Student extends Person {
    def sayHello() = println("Hello, Scala!...")
  }

  //main方法, 作为程序的主入口
  def main(args: Array[String]): Unit = {
    //3. 通过多态的形式创建Student类型的对象.
    val p: Person = new Student
    //s.sayHello()      //这样写会报错, 因为多态的弊端是: 父类引用不能直接访问子类的特有成员.
    //4. 判断其是否是Student类型的对象, 如果是, 将其转成Student类型的对象.
    if (p.isInstanceOf[Student]) {
      val s = p.asInstanceOf[Student]
      //5. 调用Student#sayHello()方法
      s.sayHello()
    }
  }
}
2.3 getClass和classOf

isInstanceOf 只能判断对象是否为指定类以及其子类的对象，而不能精确的判断出: 对象就是指定类的对象。如果要求精确地判断出对象的类型就是指定的数据类型，那么就只能使用 getClass 和 classOf 来实现.

用法

  • p.getClass可以精确获取对象的类型
  • classOf[类名]可以精确获取数据类型
  • 使用==操作符可以直接比较类型

示例

示例说明

  • 定义一个Person类
  • 定义一个Student类继承自Person类
  • 创建一个Student类对象，并指定它的类型为Person类型
  • 测试使用isInstance判断该对象是否为Person类型
  • 测试使用getClass/classOf判断该对象是否为Person类型
  • 测试使用getClass/classOf判断该对象是否为Student类型

参考代码

object ClassDemo06 {
  //1. 定义一个Person类.
  class Person
  //2. 定义一个Student类, 继承自Person类.
  class Student extends Person

  def main(args: Array[String]): Unit = {
    //3. 创建Student类型的对象, 指定其类型为Person.
    val p:Person = new Student
    //4. 通过isInstanceOf关键字判断其是否是Person类型的对象.
    println(p.isInstanceOf[Person])       	//true, 
    //5. 通过isInstanceOf关键字判断其是否是Person类型的对象.
    println(p.isInstanceOf[Student])     	//true
    //6. 通过getClass, ClassOf判断其是否是Person类型的对象.
    println(p.getClass == classOf[Person])    //false
    //7. 通过getClass, ClassOf判断其是否是Student类型的对象.
    println(p.getClass == classOf[Student])   //true
  }
}

3. 抽象类

scala语言是支持抽象类的, , 通过abstract关键字来实现.

3.1 定义

如果类中有抽象字段或者抽象方法, 那么该类就应该是一个抽象类.

  • 抽象字段: 没有初始化值的变量就是抽象字段.
  • 抽象方法: 没有方法体的方法就是一个抽象方法.
3.2 格式
// 定义抽象类
abstract class 抽象类名 {
  // 定义抽象字段
  val/var 抽象字段名:类型
  // 定义抽象方法
  def 方法名(参数:参数类型,参数:参数类型...):返回类型
}
3.3 抽象方法案例

需求

在这里插入图片描述

  • 设计4个类，表示上述图中的继承关系
  • 每一个形状都有自己求面积的方法，但是不同的形状计算面积的方法不同

步骤

  1. 创建一个Shape抽象类，添加一个area抽象方法，用于计算面积
  2. 创建一个Square正方形类，继承自Shape，它有一个边长的主构造器，并实现计算面积方法
  3. 创建一个长方形类，继承自Shape，它有一个长、宽的主构造器，实现计算面积方法
  4. 创建一个圆形类，继承自Shape，它有一个半径的主构造器，并实现计算面积方法
  5. 编写main方法，分别创建正方形、长方形、圆形对象，并打印它们的面积

参考代码

// 创建形状抽象类
abstract class Shape {
  def area:Double
}

// 创建正方形类
class Square(var edge:Double /*边长*/) extends Shape {
  // 实现父类计算面积的方法
  override def area: Double = edge * edge
}

// 创建长方形类
class Rectangle(var length:Double /*长*/, var width:Double /*宽*/) extends Shape {
  override def area: Double = length * width
}

// 创建圆形类
class Circle(var radius:Double /*半径*/) extends Shape {
  override def area: Double = Math.PI * radius * radius
}

object ClassDemo07 {
  def main(args: Array[String]): Unit = {
    val s1:Shape = new Square(2)
    val s2:Shape = new Rectangle(2,3)
    val s3:Shape = new Circle(2)

    println(s1.area)
    println(s2.area)
    println(s3.area)
  }
}
3.4 抽象字段

在scala的抽象类中，不仅可以定义抽象方法, 也可以定义抽象字段。如果一个成员变量是没有初始化，我们就认为它是抽象的。

语法

abstract class 抽象类 {
    val/var 抽象字段:类型
}

示例

示例说明

  1. 创建一个Person抽象类，它有一个String抽象字段occupation
  2. 创建一个Student类，继承自Person类，重写occupation字段，初始化为学生
  3. 创建一个Teacher类，继承自Person类，重写occupation字段，初始化为老师
  4. 添加main方法，分别创建Student/Teacher的实例，然后分别打印occupation

参考代码

object ClassDemo08 {
  //1. 定义抽象类Person, 有一个抽象字段occupation(职业)
  abstract class Person {
    val occupation:String
  }
  //2. 定义Student类继承Person, 重写抽象字段occupation.
  class Student extends Person{
    override val occupation: String = "学生"
  }
  //3. 定义Teacher类继承Person, 重写抽象字段occupation.
  class Teacher extends Person{
    override val occupation: String = "老师"
  }
  //main方法, 作为程序的主入口
  def main(args: Array[String]): Unit = {
    //4. 创建Student类的对象, 打印occupation的值.
    val s = new Student
    println(s.occupation)
    //5. 创建Teacher类的对象, 打印occupation的值.
    val t = new Teacher
    println(t.occupation)
  }
}

4. 匿名内部类

匿名内部类是继承了类的匿名的子类对象，它可以直接用来创建实例对象。Spark的源代码中大量使用到匿名内部类。学完这个内容, 对我们查看Spark的底层源码非常有帮助.

4.1 语法
new 类名() {
    //重写类中所有的抽象内容
}

注意: 上述格式中, 如果的类的主构造器参数列表为空, 则小括号可以省略不写.

4.2 使用场景
  • 当对对象方法(成员方法)仅调用一次的时候.
  • 可以作为方法的参数进行传递.
4.3 示例

需求

  1. 创建一个Person抽象类，并添加一个sayHello抽象方法
  2. 定义一个show()方法, 该方法需要传入一个Person类型的对象, 然后调用Person类中的sayHello()方法.
  3. 添加main方法，通过匿名内部类的方式来创建Person类的子类对象, 调用Person类的sayHello()方法.
  4. 调用show()方法.

参考代码

object ClassDemo09 {
  //1. 定义Person类, 里边有一个抽象方法: sayHello()
  abstract class Person{
    def sayHello()
  }

  //2. 定义一个show()方法, 该方法需要传入一个Person类型的对象.
  def show(p:Person) = p.sayHello()

  //main方法是程序的主入口
  def main(args: Array[String]): Unit = {
    //3. 通过匿名内部类创建Person的子类对象, 并调用sayHello()方法.
    new Person {
      override def sayHello(): Unit = println("Hello, Scala, 当对成员方法仅调用一次的时候.")
    }.sayHello()

    //4. 演示: 匿名内部类可以作为方法的参数进行传递.
    val p = new Person {
      override def sayHello(): Unit = println("Hello, Scala, 可以作为方法的实际参数进行传递")
    }
    show(p)
  }
}

5. 案例: 动物类

5.1 需求

已知有猫类和狗类, 它们都有姓名和年龄, 都会跑步, 而且仅仅是跑步, 没有什么不同. 它们都有吃饭的功能, 不同的是猫吃鱼, 狗吃肉. 而且猫类独有自己的抓老鼠功能, 狗类独有自己的看家功能, 请用所学模拟该需求.

5.2 目的
  • 考察继承, 抽象类, 类型转换这些知识点.
5.3 步骤
  1. 定义抽象动物类(Animal), 属性: 姓名, 年龄, 行为: 跑步, 吃饭.
  2. 定义猫类(Cat)继承自动物类, 重写吃饭的方法, 并定义该类独有的抓老鼠的方法.
  3. 定义狗类(Dog)继承自动物类, 重写吃饭的方法, 并定义该类独有的看家的方法.
5.4 参考代码
object ClassDemo10 {
  //1. 定义抽象动物类(Animal), 属性: 姓名, 年龄, 行为: 跑步, 吃饭.
  abstract class Animal{
    //1.1 属性
    var name = ""
    var age = 0

    //1.2 行为
    def run() = println("动物会跑步!...")
    //吃饭的方法.
    def eat():Unit
  }
  //2. 定义猫类(Cat)继承自动物类, 重写吃饭的方法, 并定义该类独有的抓老鼠的方法.
  class Cat extends Animal {
    //2.1 重写父类的抽象方法
    override def eat(): Unit = println("猫吃鱼")
    //2.2 定义自己的独有方法
    def catchMouse() = println("猫会抓老鼠")
  }
  //3. 定义狗类(Dog)继承自动物类, 重写吃饭的方法, 并定义该类独有的看家的方法.
  class Dog extends Animal {
    //3.1 重写父类的抽象方法
    override def eat(): Unit = println("狗吃肉")
    //3.2 定义自己的独有方法
    def lookHome() = println("狗会看家")
  }

  //main方法, 作为程序的入口
  def main(args: Array[String]): Unit = {
    //4. 测试猫类.
    //4.1 创建猫类对象.
    val c = new Cat
    //4.2 给成员变量赋值.
    c.name = "汤姆"
    c.age = 13
    //4.3 打印成员变量值
    println(c.name, c.age)
    //4.4 调用方法.
    c.eat()
    //4.5 调用猫类的独有功能: 抓老鼠
    if (c.isInstanceOf[Cat]) {
      val cat = c.asInstanceOf[Cat]
      cat.catchMouse()
    } else if(c.isInstanceOf[Dog]) {
      val dog = c.asInstanceOf[Dog]
      dog.lookHome()
    } else{
      println("您传入的不是猫类, 也不是狗类对象")
    }

    //5. 测试狗类, 自己完成.
  }
}

= println(“狗会看家”)
}

//main方法, 作为程序的入口
def main(args: Array[String]): Unit = {
//4. 测试猫类.
//4.1 创建猫类对象.
val c = new Cat
//4.2 给成员变量赋值.
c.name = “汤姆”
c.age = 13
//4.3 打印成员变量值
println(c.name, c.age)
//4.4 调用方法.
c.eat()
//4.5 调用猫类的独有功能: 抓老鼠
if (c.isInstanceOf[Cat]) {
val cat = c.asInstanceOf[Cat]
cat.catchMouse()
} else if(c.isInstanceOf[Dog]) {
val dog = c.asInstanceOf[Dog]
dog.lookHome()
} else{
println(“您传入的不是猫类, 也不是狗类对象”)
}

//5. 测试狗类, 自己完成.

}
}
落空空。
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
scala-ide-plugin-eclipse
07-29
scala eclipse插件.对应scala版本：2.10--2.11，对应eclipes版本：4.4--...update site:http://download.scala-ide.org/sdk/lithium/e44/scala211/stable/site 下载地址：http://scala-ide.org/download/current.html
scala 继承extends，with浅见
wuzb的博客
02-10 5826
近来学习scala，在继承这一块有一点小小的发现，遂记录下来，以备以后复习之用。1，当with放在子类定义的后面时，输出的结果为：300和150class Animal { val weight = 100 val doubleWeight = 2 * weight } class Tiger extends { override val weight: Int = 150 } wit...
Scala教程
anglemanyi的博客
09-20 1986
默认参数：在函数定义时，允许制定参数的默认值def printMessage(name: String = "itcats", age: Int = 18, country: String = "中国"): Unit = {}printMessage(age = 20, country = "美国")}占位符_ 的使用只能用var，不能用valvar 修饰的属性会自动生成getter / setter方法val 修饰的属性只会生成gettter 方法。
scala快速入门系列【抽象类】
大数据梦想家
01-23 1880
        本篇作为scala快速入门系列的第二十四篇博客，为大家带来的是关于抽象类的内容。 文章目录抽象类定义抽象方法抽象字段          抽象类       &n...
Scala的类定义
CyAurora的博客
08-04 2467
目录 一、⾯向对象的概念 二、Java类的定义 三、Scala定义类的属性 四、Scala⾃定义get和set⽅法 五、Bean属性 六、Scala定义类的构造器 七、cala创建对象和访问属性 一、⾯向对象的概念 如何理解抽象？ 定义⼀个类，实际上就是把⼀类事物的共有的属性和⾏为提取出来，形成⼀个物理模型(模板)。这种研究问题的⽅ 法称为抽象。 ⾯向对象编程有三⼤特征：封装、继承和多态。 封装(encapsulation)就是把抽象出的数据和对数据的...
Scala核心基础二
asdsdwuwang的博客
12-07 386
scala是支持面向对象的，也有类和对象的概念。我们依然可以基于scala语言来开发面向对象的应用程序。 #简写方式 #用法 如果类是空的，没有任何成员，可以省略 如果构造器的参数为空，可以省略 #示例 使用简写方法重新创建Person类和对象参考代码 #1.1 定义和访问成员变量 一个类会有自己的属性，例如：人这样一个类，有自己的姓名和年龄。我们接下来学习在类中定义、和访问成员变量。步骤参考代码 #1.2 使用下划线初始化成员变量 scala中有一
Scala第一章节
qq_36973540的博客
09-23 468
Scala第一章节 章节目标 理解Scala的相关概述 掌握Scala的环境搭建 掌握Scala小案例: 做最好的自己 1. Scala简介 1.1 概述 ​ Scala(斯嘎拉)这个名字来源于"Scalable Language(可伸缩的语言)", 它是一门基于JVM的多范式编程语言, 通俗的说: Scala是一种运行在JVM上的函数式的面向对象语言. 之所以这样命名, 是因为它的设计目标是: 随着用户的需求一起成长. Scala可被广泛应用于各种编程任务, 从编写小型的脚本到构建巨型系统, 它都能
Scala中的类和对象：定义、创建和使用
jakelihua
10-31 508
在Scala中，我们使用class关键字来定义类，并使用new关键字来创建类的对象。nameage上述代码中，我们定义了一个名为Personname和age。greet方法用于打印出一个问候语，其中包含了对象的name和age属性。然后，我们使用new关键字创建了一个Person对象，并将其赋值给person变量。最后，我们调用person对象的greet方法来打印问候语。在上述代码中，我们创建了一个名为Person的类，并传递了两个参数name和age。然后，我们创建了一个名为person的。
Scala之面向对象
Little To More
03-05 305
Scala的面向对象：类似Java 一、面向对象的基本概念 1、封装：类class 2、继承 3、多态 二、定义类：关键字class 举例：创建一个学生类 //代表一个学生的信息 class Student1 { //定义学生的属性 private var stuID:Int = 0 private var stuName:String = "Tom" private var ag...
Scala语法教程
weixin_51497782的博客
02-17 1843
Scala详细的语法教程，非常细致
scala-sbt-mesos-framework.g8
07-06
在我们开始之前你需要 你需要 你需要 你需要你需要程序克隆这个giter8模板 $ g8 mesosphere/scala-sbt-mesos-framework package [com.domain]: io.mycompany name [My Mesos Framework]: My Great Framework ...
scala-intellij-bin-2018.3.2.zip
12-06
scala-intellij-bin-2018.3.2.zip插件，亲测可用！！！scala-intellij-bin-2018.3.2.zip插件，亲测可用！！！scala-intellij-bin-2018.3.2.zip插件，亲测可用！！！
scala-js-binding:ScalaJS html绑定库
05-14
scalajs-binding是一个scala-scala-js框架，可让您 将HTML标记绑定到ScalaJS视图类及其属性 具有React事件流（您可以将dom事件绑定到Scala.Rx定义） 将您的集合绑定到html元素，并将html元素作为项目模板 将属性...
scala-maven-plugin-4.4.0.jar
08-18
maven的scala编译包
12_Scala_package
m0_52474839的博客
04-29 926
Scala是一门完全面向对象语言，摒弃了Java很多不是面向对象的语法，虽然如此其面向对象思想和Java完全一致。假如我想使用util的Date，那么我会将sql屏蔽掉。也就是说先看当前包里面有没有，没了，自上而下依次寻找。基本语法 package object xx{scala中的Predef对象的方法无需导入；在包对象中写的所有方法，同一包下都可以使用；上述导包，两个类中都有Date，引起歧义。注意：区分类起别名和屏蔽类的写法。java 中的常规用法。
Scala应用 —— JDBC的创建
Byyyi耀的博客
05-02 1946
用Scala实现JDBC的创建
10_Scala控制抽象*了解
m0_52474839的博客
04-29 462
抽象函数-> 函数没有输入只有返回 ->抽象方法的调用时候，不能有小括号。
21_Scala集合_可变数组ArrayBuffer
最新发布
m0_52474839的博客
05-06 179
Java中的remove操作和ArrayBuffer操作不同。–感觉优点类似于Java的ArrayList。–请注意下面的mutable。–同不可变数组Array。
19_Scala集合概述
m0_52474839的博客
05-06 118
原始数据：处理数据时，一般要从数据源获取数据，但是数据源的数据一般不能被改变，如果必须要改变，也是创建新的数据。3.Map 存储无序，存储KV键值对，KEY不重复，V可重复；StringBuilder可变字符串，很多方法就是改变其自身内容。1.Seq 存储有序数据可重复 类比 List。函数式编程语言更侧重集合本身提供的哪些功能；String不可变字符传，创建新的字符串。2.Set 存储无序数据不可重复。可变不可变集合区分 --> 根据包。scala与Java有所不同。不可变集合 & 可变集合。
scala和maven-scala-plugin对应的版本
06-02
scala和maven-scala-plugin对应的版本关系如下： | Scala Version | maven-scala-plugin Version | |:-------------:|:-------------------------:| | 2.10.x | 2.15.2 | | 2.11.x | 2.15.2 | | 2.12.x | 3.2.2 | |...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值