Scala泛型、隐式转换和隐式参数、视图介绍、Scala中的上界、下界、结合柯里化进行隐式转换

最新推荐文章于 2023-05-07 11:36:25 发布
最新推荐文章于 2023-05-07 11:36:25 发布
阅读量1.9k 收藏 6
点赞数 2
分类专栏： # Scala(多范式的编程语言) 文章标签： scala
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tototuzuoquan/article/details/74084416
版权

二、泛型

一、Scala泛型
1. 泛型介绍
泛型用于指定方法或类可以接受任意类型参数，参数在实际使用时才被确定，泛型可以有效地增强程序的适用性，使用泛型可以使得类或方法具有更强的通用性。泛型的典型应用场景是集合及集合中的方法参数，可以说同java一样，scala中泛型无处不在，具体可以查看scala的api。
2. 泛型类、泛型方法
泛型类：指定类可以接受任意类型参数。
泛型方法：指定方法可以接受任意类型参数。
3. 案例
案例一：

package cn.toto.gen

/**
  * Created by toto on 2017/7/1.
  * 下面的意思就是表示只要是Comparable就可以传递,下面是类上定义的泛型
  */
/*class MrRight[T <:Comparable[T]] {
  //定义一个选择方法，实现选择的功能
  def choose(first : T,second : T) : T = {
    if(first.compareTo(second) > 0) first else second
  }
}*/

/**
  * 在类上定义泛型可以，当然，也可以在方法上定义泛型，定义的方式如下：
  */
class MrRight {
  def choose[T <: Comparable[T]](first:T,second:T) : T = {
    if(first.compareTo(second) > 0) first else second
  }
}

object MrRight {
  def main(args: Array[String]): Unit = {
//    //如果是类上定义的泛型，通过下面的方式调用
//    val mr = new MrRight[Boy]
//    val b1 = new Boy("laoduan",99)
//    val b2 = new Boy("laozhao",9999)
//    val boy = mr.choose(b1,b2)
//    //结果是：laozhao
//    println(boy.name)

    //如果是在方法上定义的泛型，可以使用下面的方式：
    var mr = new MrRight
    val b1 = new Boy("laoduan",99)
    val b2 = new Boy("laozhao",9999)
    val boy = mr.choose[Boy](b1,b2)
    //结果同样是：laozhao
    println(boy.name)
  }
}

案例二：

package cn.toto.scala.enhance

/**
  * Created by toto on 2017/7/1.
  * 泛型类，泛型方法
  * 泛型用于指定方法或类可以接受任意类型参数
  * 参数在实际使用时才被确定
  * 泛型可以有效地增强程序的适用性
  * 使用泛型可以使用得类或方法具有更强的通用性
  */
//泛型类    F S T是类型的参数
class GenericClass[F,S,T](val f:F,val s:S,val t:T)
object GenericDemo {

  //泛型方法
  def getData[T](list:List[T]) = list(list.length/2)

  /**
    * 运行结果：
    * 26
    * 3
    */
  def main(args : Array[String]): Unit = {
    //实例化方式1
    val gc1 = new GenericClass("lisha",26,"beijing")
    //实例化方式2
    val gc2 = new GenericClass[String,String,Int]("lisha","beijing",26)

    println(getData(List("lisha",26,"beijing")))

    val t = getData[Int] _
    println(t(List(1,2,3,4,5)))
  }
}

二、 隐式转换和隐式参数

1． 概念
隐式转换和隐式参数是Scala中两个非常强大的功能，利用隐式转换和隐式参数，你可以提供优雅的类库，对类库的使用者隐匿掉那些枯燥乏味的细节。
2． 作用
隐式的对类的方法进行增强，丰富现有类库的功能
3． 隐式转换函数
是指那种以implicit关键字声明的带有单个参数的函数。

可以通过：:implicit –v这个命令显示所有做隐式转换的类。
4． 隐式转换例子

package cn.toto.impli

import java.io.File
import scala.io.Source

/**
  * 这个案例是为了一下读出文件中的内容,目的类似通过下面的read方法直接读取出其中的内容：
  * var file = new File("E:\\wordcount\\input\\1.txt");
    var contents = file.read();
  *
  * Created by toto on 2017/7/1.
  * 隐式的增强File类的方法
  */
class RichFile(val from : File){
  //定义一个read方法，返回
  def read() : String = Source.fromFile(from.getPath).mkString
}

object RichFile {
  //隐式转换方法（将原有的File类型转成了file类型，在用的时候需要导入相应的包）
  implicit def file2RichFile(from : File) = new RichFile(from)
}

object MainApp {
  def main(args: Array[String]): Unit = {
    val file = new File("E:\\wordcount\\input\\a.txt");
    //装饰模式，显示的增强(本来想实现：val contents = file.read()，但是却使用RichFile的方式，所以是显示的增强)
    val rf = new RichFile(file)
    val contents = rf.read();

    //目的是使用File的时候不知不觉的时候直接使用file.read()方法，所以这里就要做隐式转换

    //导入隐式转换，._将它下满的所有的方法都导入进去了。 导包的代码，可以
    import RichFile._
    //这里没有的read()方法的时候，它就到上面的这一行中的找带有implicit的定义方法
    var content = new File("E:\\wordcount\\input\\a.txt").read
    println()

    //import RichFile.file2RichFile
    //println(file2RichFile(new File("E:\\wordcount\\input\\1.txt")).read)
  }
}
package cn.toto.scala

import java.awt.GridLayout

/**
  * Created by ZX on 2015/11/13.
  */
object ImplicitContext{
  //implicit def girl2Ordered(g : Girl) = new Ordered[Girl]{
  //  override def compare(that: Girl): Int = if (g.faceValue > that.faceValue) 1 else -1
  //}

  implicit object OrderingGirl extends Ordering[Girl]{
    override def compare(x: Girl, y: Girl): Int = if (x.faceValue > y.faceValue) 1 else -1
  }
}

class Girl(var name: String, var faceValue: Double){
  override def toString: String = s"name : $name, faveValue : $faceValue"
}

//class MissRight[T <% Ordered[T]](f: T, s: T){
//  def choose() = if(f > s) f else s
//}
//class MissRight[T](f: T, s: T){
//  def choose()(implicit ord: T => Ordered[T]) = if (f > s) f else s
//}

class MissRight[T: Ordering](val f: T, val s: T){
  def choose()(implicit ord: Ordering[T]) = if(ord.gt(f, s)) f else s
}

object MissRight {
  def main(args: Array[String]) {
    import ImplicitContext.OrderingGirl
    val g1 = new Girl("yuihatano", 99)
    val g2 = new Girl("jzmb", 98)
    val mr = new MissRight(g1, g2)
    val result = mr.choose()
    println(result)
  }
}

视图介绍

隐含参数和方法也可以定义隐式转换，称作视图。视图的绑定从另一个角度看就是implicit的转换。主要用在两个场合：
当一个T类型的变量t要装换成A类型时
当一个类型T的变量t无法拥有A类型的a方法或变量时
其实视图的绑定是为了更方便的使用隐式装换
用符号 <% 表示。

Scala中的上界、下界

1．上界、下界介绍
在指定泛型类型时，有时需要界定泛型类型的范围，而不是接收任意类型。比如，要求某个泛型类型，必须是某个类的子类，这样在程序中就可以放心的调用父类的方法，程序才能正常的使用与运行。此时，就可以使用上下边界Bounds的特性；
Scala的上下边界特性允许泛型类型是某个类的子类，或者是某个类的父类；

(1) U >: T

这是类型下界的定义，也就是U必须是类型T的父类(或本身，自己也可以认为是自己的父类)。

(2) S <: T

这是类型上界的定义，也就是S必须是类型T的子类（或本身，自己也可以认为是自己的子类)。

下面是视图介绍和上界、下界的示例代码：
下面定义两个类

package cn.toto.gen

/**
  * Created by toto on 2017/7/1.
  */
class Boy(val name : String,var faceVlue : Int) extends Comparable[Boy] {
  override def compareTo(o: Boy): Int = {
    this.faceVlue - o.faceVlue
  }
}
package cn.toto.gen

/**
  * Created by toto on 2017/7/1.
  */
class Girl(val name:String,var faceValue:Int) {

}
这里写代码片
package cn.toto.gen

import java.awt.GridLayout
import java.io.File

import cn.toto.impli.RichFile

/**
  * Created by ZhaoXing on 2016/8/18.
  */
object MyPreDef {
  //针对viewbound方式的
//  implicit def girl2Ordered(g : Girl) = new Ordered[Girl] {
//    override def compare(that: Girl): Int = {
//      g.faceValue - that.faceValue
//    }
//  }

  //针对Ordering类型的
  implicit object Girl2Ordering extends Ordering[Girl] {
    override def compare(x: Girl, y: Girl): Int = {
      x.faceValue - y.faceValue
    }
  }
}
package cn.toto.gen

/**
  * Created by toto on 2017/7/1.
  * 下面的意思就是表示只要是Comparable就可以传递,下面是类上定义的泛型
  */
/*class MrRight[T <:Comparable[T]] {
  //定义一个选择方法，实现选择的功能
  def choose(first : T,second : T) : T = {
    if(first.compareTo(second) > 0) first else second
  }
}*/

/**
  * 在类上定义泛型可以，当然，也可以在方法上定义泛型，定义的方式如下：
  */
class MrRight {
  def choose[T <: Comparable[T]](first:T,second:T) : T = {
    if(first.compareTo(second) > 0) first else second
  }
}

object MrRight {
  def main(args: Array[String]): Unit = {
//    //如果是类上定义的泛型，通过下面的方式调用
//    val mr = new MrRight[Boy]
//    val b1 = new Boy("laoduan",99)
//    val b2 = new Boy("laozhao",9999)
//    val boy = mr.choose(b1,b2)
//    //结果是：laozhao
//    println(boy.name)

    //如果是在方法上定义的泛型，可以使用下面的方式：
    var mr = new MrRight
    val b1 = new Boy("laoduan",99)
    val b2 = new Boy("laozhao",9999)
    val boy = mr.choose[Boy](b1,b2)
    //结果同样是：laozhao
    println(boy.name)
  }
}

package cn.toto.gen

/**
  * Created by toto on 2017/7/1.
  */
//viewbound必须存在一个隐式转换方法,视图界定，必须有一个隐式转换的方法
//class MissRight[T <% Ordered[T]] {
//  def choose(first:T,second : T) : T = {
//    //这里的之所以可以用'>',是因为这里的T可以转换成Order的类型
//    if(first > second) first else second
//  }
//}

//如果使用上下文界定，必须存在一个隐式转换的值，特点是使用Ording，但是不需要使用Ordering[T]
class MissRight[T : Ordering] {
  def select(first : T,second : T) : T = {
    //通过使用implicitly转换类型
    val ord = implicitly[Ordering[T]]
    if(ord.gt(first,second)) first else second
  }
}

object MissRight {
  def main(args: Array[String]): Unit = {
    def main(args: Array[String]): Unit = {
      //这里是使用viewbound方式的。
//      import MyPreDef._
//      val mr = new MissRight[Girl]
//      val g1 = new Girl("ab",90)
//      val g2 = new Girl("aaa",999)
//      val g = mr.choose(g1,g2)
//      println(g.name)

      //这里是针对Order类型的
      import MyPreDef._
      val mr = new MissRight[Girl]
      val g1 = new Girl("ab",90)
      val g2 = new Girl("aaa",999)
      val g = mr.select(g1,g2)
      println(g.name)
    }
  }
}

结合柯里化进行隐式转换：
代码如下：

package cn.com.toto.gen

/**
  * Created by toto on 2017/7/2.
  */
class Girl(val name : String,var faceValue:Int) {

}

package cn.com.toto.gen

import cn.toto.impli.RichFile

/**
  * Created by toto on 2017/7/2.
  */
object MyPreDef {
  implicit object Girl2Ordering extends Ordering[Girl] {
    override def compare(x: Girl, y: Girl): Int = {
      x.faceValue - y.faceValue
    }
  }
}

package cn.com.toto.gen

/**
  * Created by toto on 2017/7/2.
  */
class MissR[T] {

  //如果利用柯里化传入一个隐式转换函数，其作用和Viewbound是一样的，都需要一个隐式转换方法或函数
  def choose(f: T, s: T)(implicit ord: T => Ordered[T]) : T = {
    if (f > s) f else s
  }

  //如果利用柯里化传入一个隐式的类型， 其作用和Contextbound是一样的，都需要一个隐式转换的值
  def select(f: T, s: T)(implicit ord: Ordering[T]) : T = {
    if(ord.gt(f, s)) f else s
  }

  def random(f: T, s: T)(implicit ord: Ordering[T]) : T = {
    import Ordered.orderingToOrdered
    if(f > s) f else s
  }
}

object MissR {
  def main(args : Array[String]): Unit = {
    import MyPreDef._
    val mr = new MissR[Girl]
    val g1 = new Girl("aaa", 80)
    val g2 = new Girl("bbb", 90)
    //val g = mr.choose(g1, g2)
    val g = mr.random(g1, g2)
    //运行结果是：bbb
    println(g.name)
  }
}
涂作权的博客
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
专栏目录
Scala—— 12.隐式转换
01-07
1.隐式转换函数 隐式转换函数是以implicit关键字声明的带有单个参数的函数，这种函数将会自动应用，将值从一种类型转换为另一种类型。 object boke_demo01 { def main(args: Array[String]): Unit = { //编写一个隐式函数转成 Double->Int 转换 //隐式函数应当在作用域才能生效 implicit def f1(d: Double): Int = { //底层 生成 f1$1 d.toInt } implicit def f2(f: Float): Int = {
Scala的隐式转换
最新发布
m0_46168848的博客
09-03 597
scala隐式转换
debugging-scala-implicits-in-intellij:如何在IntelliJ中调试Scala隐式转换和参数
05-09
在IntelliJ中调试Scala隐式 本文档概述了用于静态分析IntelliJ中的Scala隐式方法的几种补充方法。 JetBrains提供了的，但不包括有关分析富集对象的说明。 注意：这些快捷方式适用于OSX。 查看隐式转换 突出显示隐式转换的对象。 重要说明：在研究丰富的对象时，您必须仅突出显示对象，而不是突出显示的方法。 这是因为对象就是要转换的对象。 选择该方法将解析该方法返回的对象的隐式转换。 CTRL + Q 查看实际的隐式参数 突出显示方法调用站点。 CMD + SHIFT + P 如果收到“找不到参数”，请参阅 查看隐式转换的实际隐式参数 以下内容需要临时代码修改： 执行步骤。 突出显示适当的隐式转换函数。 ALT + ENTER （然后按ENTER选择“显式”）。 执行步骤。 查看无隐式代码 这是不得已的方法：它显示“未散布”的Scala代码，如果您
Scala隐式转换和隐式参数.md
08-07
Scala隐式转换和隐式参数.md
scala中的隐式类型转换的实现
08-25
主要介绍了scala中的隐式类型转换的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
scala的泛型类上下界
汉子一枚
02-15 774
上下界 需求： 我们在定义方法/类的泛型时，限定必须从哪个类继承、或者必须是哪个类的父类。此时，就需要使用到上下界。 上界定义 使用<: 类型名表示给类型添加一个上界，表示泛型参数必须要从该类（或本身）继承 语法格式 [T <: 类型] 示例 示例说明 定义一个Person类 定义一个Student类，继承Person类 定义一个demo泛型方法，该方法接收一个Array参数， 限定d...
Scala隐式参数
鸭梨的博客
05-07 515
在这个例子中，我们定义了一个类型类Greetable，它有一个参数列表，包含一个名为greeting的String类型参数和一个名为a的类型参数。在这个例子中，我们定义了一个名为greet的函数，它有两个参数列表，第一个参数列表包含一个名为name的String类型参数，第二个参数列表包含一个名为greeting的String类型参数。在这个例子中，我们定义了一个名为greet的函数，它有两个参数列表，第一个参数列表包含一个名为name的参数，第二个参数列表包含一个名为greeting的参数。
Scala学习之路 （九）Scala的上界和下届
weixin_34198583的博客
04-18 2260
一、泛型 1、泛型的介绍 泛型用于指定方法或类可以接受任意类型参数，参数在实际使用时才被确定，泛型可以有效地增强程序的适用性，使用泛型可以使得类或方法具有更强的通用性。泛型的典型应用场景是集合及集合中的方法参数，可以说同java一样，scala中泛型无处不在，具体可以查看scala的api。  2、泛型类、泛型方法  泛型类：指定类可以接受任意类型参数。  泛型方法：指定方法可以接受任意...
scala【隐式参数、隐式函数、隐式类】
lyq7269的博客
07-28 1183
一、隐式参数 隐式参数是级别在中间的一种参数形式。在调用是可以写也可以不写。在有隐式参数的方法中，调用此方法，那么JVM虚拟机首先寻找的是传参，再传参没有找到的情况下，才会去寻找隐式参数，如果不巧的是隐式参数也没有，这是JVM还会去寻找参数默认值，如果都没有，则调用时会报错，提示需要传参，要么就去写隐式参数。 案例演示： implicit val num:Int=10 def sum2(a:Int)(implicit b:Int):Int={ a+b } def main(args: Array
Scala中的隐式参数
段渣渣推轮子的飙车场
07-11 466
版权声明：未经允许，随意转载，请附上本文链接谢谢（づ￣3￣）づ╭❤～ Scala中的隐式参数 隐式参数的定义：指的是在函数或者方法中，定义一个用implicit修饰的参数，此时Scala会在作用域内尝试寻找一个指定类型的，用implicit修饰的对象，即隐式值，并注入参数 作用域规则：插入的隐式转换必须以单一标识符的形式处于作用域中，或与转换的源或目标类型关联在一起。 Scala 编译器...
scala 隐式转换与隐式参数的使用方法
08-25
主要介绍了scala 隐式转换与隐式参数的使用方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
scala中的隐式转换
杨小妹的刘小哥
04-10 288
scala中的隐式转换分为三种 1. 隐式参数 2. 隐式的类型转换 3. 隐式类 1.隐式参数 方法的参数是隐式参数，如果你没有传递参数的话，编译器在编译的时候会自动的从当前的上下文中找一个隐式值（符合参数的类型的隐式值）不能同时有多个符合的条件，因为编译器没有办法判断谁是更合适的。 //say、add、add1方法就是隐式参数 def say(implicit content:Stri...
Scala的隐式转换详解
m0_51697147的博客
04-20 643
​ 隐式转换是在Scala编译器进行类型匹配时，如果找不到合适的类型，那么隐式转换会让编译器在作用范围内自动推导出来合适的类型。 一、隐式值与隐式参数 隐式值是指在定义参数时前面加上implicit。隐式参数是指在定义方法时，方法中的部分参数是由implicit修饰【必须使用柯里化的方式，将隐式参数写在后面的括号中】。隐式转换作用就是：当调用方法时，不必手动传入方法中的隐式参数，Scala会自动在作用域范围内寻找隐式值自动传入。 ​
scala隐式转换（隐式函数、隐式值、隐式类）implicit
攻城狮Kevin
01-10 333
目录 隐式转换的目的： 隐式转换的时机： 一、隐式函数 实例1：隐式函数类型转换 实例2：隐式函数 &amp; 类结合使用 二、隐式变量（隐式值）&amp; 隐式参数 三、隐式类 实例：与 隐式函数 &amp; 类结合使用的对比 四、隐式转换机制 隐式转换的目的： 通过隐式转换，程序员可以在编写Scala程序时故意漏掉一些信息，让编译器去尝试在编译期间自动推导出这些信息来，这...
Scala 入门-泛型，上界，下界
2.wa
01-08 422
专栏原创出处：github-源笔记文件 ，github-源码 ，欢迎 Star，转载请附上原文出处链接和本声明。 Scala 编程语言专栏系列笔记，系统性学习可访问个人复盘笔记-技术博客 Scala 编程语言 什么是泛型类 泛型类指可以接受类型参数的类，在 类名 后 + [类型参数 ],例如：class Stack[A]。 泛型类在集合类中被广泛使用，例如 Scala 集合的 List、M...
Scala泛型、上界、下界、视图用法
zhangxm_qz的博客
08-19 731
文章目录泛型类型约束上下界上界下界视图界定上下文界定 泛型 使用示例 def test={ //应用1 val msg = new IntMessage(1) println(msg) val msg2 = new StringMessage[String]("class") println(msg2) //应用2 val class01 = new EnglishClass[String,String,String]("春季","大数据","初级") val class02
Scala泛型上下界
Jamie's Blogs
09-21 291
上下界 需求： 我们在定义方法/类的泛型时，限定必须从哪个类继承、或者必须是哪个类的父类。此时，就需要使用到上下界。 上界定义 使用<: 类型名表示给类型添加一个上界，表示泛型参数必须要从该类（或本身）继承 语法格式 [T <: 类型] 示例 示例说明 定义一个Person类 定义一个Student类，继承Person类 定义一个demo泛型方法，该方法接收一个Array参数...
Scala 的隐式转换与隐式参数
CodeFlight
08-25 263
文章目录Scala 的隐式转换与隐式参数隐式转换（Implicit conversions）隐式规则标记规则（Marking rule）作用域规则（Scope rule）每次一个规则（One-at-a-time rule）显示优先原则（Explicits-first rule）隐式转换命名隐式应用场景类型的转换接受者的转换隐式类（Implicit class）隐式参数隐式参数的风格规则上下文边界（Context bounds）隐式转换适用情况多转换同时适用调试 Scala 的隐式转换与隐式参数 隐式转换（I
scala隐式参数、隐式函数、隐式类详解
qianchun22的博客
10-26 652
scala关键字"implicit"详解隐式参数定义示例隐式函数定义示例类型转换类型增强隐式类定义示例 隐式参数 定义 1、定义一个普通变量，使用 implicit 关键字修饰，定义一个函数调用这个变量当参数时，此时这个参数就被称为隐式参数 2、隐式参数的作用：减少提供函数参数的数量，让某些参数拥有隐藏的值（隐式变量） 示例 def main(args: Array[String]): Unit = { //隐式参数(每种类型只能有一个) implicit var a:Int = 10
scala中的各种函数 如柯里化函数 隐士函数 ....详解
05-13
在Scala中，函数是一等公民，可以作为参数传递和返回值。Scala也支持许多高级函数特性，包括柯里化函数和隐式函数。 1. 柯里化函数 柯里化函数是将多个参数的函数转换成一系列单参数函数的过程。例如，一个接受两个参数的函数可以被柯里化为两个单参数函数。 ```scala def add(x: Int, y: Int) = x + y // 柯里化函数 def addCurried(x: Int)(y: Int) = x + y ``` 在柯里化函数中，每个参数都是一个单独的函数参数列表。这样做有助于提高代码的可读性和重用性。 2. 隐式函数 隐式函数是一种特殊类型的函数，它可以将一个类型转换为另一个类型。这种转换是在编译时自动完成的，而不需要显式调用函数。 ```scala // 定义一个隐式函数将Int类型转换成String类型 implicit def intToString(i: Int): String = i.toString // 使用隐式函数将Int类型转换成String类型 val s: String = 42 ``` 在上面的例子中，当将一个Int类型的值赋给一个String类型的变量时，编译器会自动调用intToString函数，将Int类型转换成String类型。 除了类型转换，隐式函数还可以用于隐式参数和隐式类。隐式参数是一种特殊类型的函数参数，它可以在函数调用时自动提供。隐式类是一种特殊类型的类，它可以在需要时自动转换成其他类型。 Scala中的函数是非常强大和灵活的，柯里化函数和隐式函数是其中两个重要的特性。它们可以提高代码的可读性、重用性和灵活性，使程序开发更加高效和简洁。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

涂作权的博客

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值