day65、66 Scala 面向对象 面向函数

最新推荐文章于 2024-04-29 21:14:27 发布
最新推荐文章于 2024-04-29 21:14:27 发布
阅读量441 收藏
点赞数
文章标签： scala java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41464008/article/details/122136930
版权

文章目录

I know, i know
地球另一端有你陪我




一、Hello World

Scala 是 Scalable Language 的简写，是一门多范式的编程语言

Scala是把函数式编程思想和面向对象编程思想结合的一种编程语言

在函数式编程中，函数是基本单位，他几乎被用作一切，包括最简单的计算，甚至连变量都被计算所取代；
在函数式编程中，变量只是一个名称，而不是一个存储单元，这是函数式编程与传统的命令式编程最典型的不同之处。

大数据计算引擎 Spark 由 Scala 编写

从 Hello World 开始

我们知道，依赖于 JVM 的Java 程序，函数的入口是 main 方法
而它的修饰词是固定的（public static void）
而 Scala 中是没有这些修饰词的，取而代之的是 object
被他修饰的类中，所有的成员都将是静态的（static）

package day65


/*
    类在被加载到 jvm 中，会在内存中存在一个该类的“类对象”，
    该对象有且只有只有一个（单例模式）
    通过该对象可以直接调用方法中的静态成员

    scala 和 java 一样，需要先编译，在 jvm 中运行
    jvm 需要 main函数，而 main 函数必须是由 public 和 static 修饰
    scala 中并没有这个修饰词，于是提供了一个object，
    由object修饰的类中所有的成员都是静态的，可以通过“类对象”直接调用
    由class修饰的类中所有的成员都是普通的，需要类的对象进行调用


 */

object ScalaDemo1 {
  // 程序的入口 main
  def main(args: Array[String]): Unit = {

    print("Hello World")
  }
}

1、变量的定义 基本数据类型 结构体

定义变量时都要加上 val(不可变) 或 var(可变)
Scala 本质依然依赖大部分 Java，所以保留了很多 Java 中有的元素，
包括八个基本数据类型

package day65

import java.io.{BufferedReader, FileReader}
import java.sql.{Connection, DriverManager, PreparedStatement, ResultSet}
import scala.io.{BufferedSource, Source}

object ScalaDemo2 {

  def main(args: Array[String]): Unit = {

    //val 不可变
    //var 可变

    val a = 1

    var b = 10
    b = 11

    println(a)
    println(b)

    /*
        基本数据类型(首字母需要大写)

        Byte Short Int Long
        Float Double
        Character
        Boolean
     */

    // 定义变量
    val byte1: Byte = 1
    val short1: Short = 1
    val int1: Int = 1
    val long1: Long = 1

    val float1: Float = 1
    val double1: Double = 1

    val bool1: Boolean = true
    val bool2: Boolean = false

    val char1: Char = 'a'

    // String 是引用类型
    val string1: String = "fgh 韭菜盒子"

    /*
       隐式转换
       由于scala的底层依然是java，所以本身涵盖了大本分java方法
       而scala中新增了很多方法，这种额外添加方法的动作叫做隐式转换
       后面会详细说
    */

    val splits: Array[String] = string1.split(" ")

    // 通过下标取需要用小括号
    println(splits(0))
    println(splits(1))

    //拼接字符串
    val str1: String = "123"
    val str2: String = "456"

    // 直接 +
    val str3 = str1 + str2
    println(str3)

    // 利用StringBuilder或Buffer
    val builder: StringBuilder = new StringBuilder()
    builder.append(str1).append(str2)
    println(builder)

      // scala特有方式，类似引用
      // 底层依然是StringBuilder
      // 建议加大括号，当首个字符是_，不加会出错
      println(s"${str1}${str2}")

    // 类型转换
    // 通过Java中的方法
    val int2: Int = 1
    val str4: String = String.valueOf(int2)
    val int5: Integer = Integer.valueOf(str4)

    // 通过scala中的方法，注意没有括号
    val srt5 = int2.toString
    val byte5 = int2.toByte
    val short5 = int2.toShort

    // 关于 *
    // 这里的*是一个方法
    // scala 中的方法调用也可以也不加上 "."
    println("*".*(100))
    println("*" * 100)


    // 选择结构
    if(1>2){
      println(">")
    } else if(1==2){
      println("=")
    } else {
      println("<")
    }


    // 循环
    var cnt:Int = 1
    var sum:Int = 0
    while (cnt <= 100){
      sum += cnt
      cnt += 1
    }
    println(sum)


    do{
      println("说啥都要打印")
    }while(false)


    val str6:String = "1,2,3,4,5"
    val array1: Array[String] = str6.split(",")

    // for each 循环
    for (elem <- array1) {
      println(elem)
    }

    // scala 采用函数式编程来遍历
    // 将函数作为参数，注意不加（）
    array1.foreach(println)
    array1.map(print)


    // 文件读写
    // java的方法
    val br: BufferedReader = 
    		new BufferedReader(new FileReader("data/students.txt"))

    var line:String = br.readLine()

    //while((line=br.readLine())!=null) scala不能解析这句

    while (line!= null){
      System.out.println(line)
      line = br.readLine()
    }


    println("*" * 100)

    // scala io 的方式
    // 也可以读url等等
    val source: BufferedSource = Source.fromFile("data/students.txt")
    // 可以直接输出
    source.foreach(print)

    // 也可以弄一个迭代器慢慢玩
    val lines: Iterator[String] = source.getLines()
    for (elem <- lines) {
      println(elem)
    }

    println("*" * 100)


    // 链式编程
    Source
      .fromFile("data/students.txt")
      .getLines()
      .foreach(println)


    // 连接 mysql
    val conn: Connection = DriverManager.getConnection
    		("jdbc:mysql://master:3306/student","root","123456")

    val ps: PreparedStatement = conn.prepareStatement
    		("select * from student where age<?")

    ps.setString(1,"23")

    val rs: ResultSet = ps.executeQuery()
    val id: String = rs.getString("id")
    val name: String = rs.getString("name")
    val age: Int = rs.getInt("age")

    println(s"${id},${name},${age}")

    ps.close()
    conn.close()
  }
}

二、面向对象


1、类

package day65

/*
      面向对象

      类
 */

class student(id: String, name: String) {
  // 关于构造方法。这个类{}中就是构造方法
  // 需要在类名处就定义好参数
  // 即此处的 id name age
  // 在构造方法的赋值时，为了不冲突，一般会加一个_
  //不能使用this.id = id 的方法
  val _id: String = id
  val _name: String = name
  var _age: Int = _
  // _下划线表示稍后赋值，定义时必须声明类型，以及可变

  // alt+ins 可以快捷重写超类object已经定义好的类，例如 toString
  // 可以发现这种格式已经接近变量
  // 体现出了scala中面向函数的特点
  // 自动带出来的会没有{}，记得加上
  override def toString = s"student(${_id}, ${_name}, ${_age})"

  //原型是
  /*
      override def toString():String={
          return s"student($_id, $_name, $_age)"
      }
      不写return会默认返回最后一行，可以省略
      返回值类型可以推断，也可以省略，代码一行，{}也可以省略
      没有参数，（）也可以省略
   */


  // 如果想要重载多个构造方法，需要使用 this 有点类似构造方法的继承
  def this(id: String, name: String, age: Int) {
    // 首先需要调用默认构造方法
    this(id, name)
    _age = age
    // 且赋值的时候不能加类型
    // 感觉像是只能越写越长，所以第一个构造方法很重要
  }
}


// 不同修饰词下的同名类可以共存
object student {

  def main(args: Array[String]): Unit = {

    // 创建对象
    val stu1: student = new student("1001", "韭菜盒子")
    val stu2: student = new student("1002", "fgh", 21)

    // 取对象的属性
    println(stu1._name)
    println(stu1._age)
    println(stu1.toString)
    println(stu2 toString)
    println(stu1)
  }
}

2、继承、多态（一点点）

package day65

class A(id: String, name: String) {

  val _id: String = id
  val _name: String = name

  override def toString = s"A(_id=${_id}, _name=${_name})"

  def printAB(): Unit ={
    println("A")
  }
}

// 继承的时候要带上父类的属性(像是子类构造方法的初始化)
class B(id: String, name: String, age: Int) extends A(id, name) {

  // 初始化只需要对多出来成员的进行
  val _age: Int = age

  override def printAB(): Unit ={
    println("B")
  }

  //重写父类方法
  override def toString = 
  	s"B(_id=${_id}, _name=${_name}，_age=${_age})"
}


object ScakaDemo4 {

  def main(args: Array[String]): Unit = {

    val a: A = new A("1001", "A")
    val b: B = new B("1002", "B", 21)

    println(a)
    // 继承父类方法
    println(b)

    a.printAB()
    b.printAB()


    // 多态
    def printAABB(a: A): Unit ={
      a.printAB()
    }

    printAABB(a)
    printAABB(b)
  }
}

3、样例类（case class）

可以说是为了懒人特地设计好的，已经封装好绝大部分常用方法
只需要创建时定义好成员属性，类用 case class 修饰

package day65

// 样例类
// 在样例类中定义的参数 默认由val修饰 不可以改变
// 如果需要对属性重新赋值 则需要在定义的时候 加上 var修饰
// 会自动实现get set（针对var修饰的属性）方法，
// 还会实现序列化接口（可以在网络中进行传输）
case class Student(var id:String
                   ,name:String
                   ,gender:String)

object ScalaDemo5{

  def main(args: Array[String]): Unit = {

    // 创建样例类的对象
    // new关键字可以省略
    val stu1 = Student("1001","fgh","male")
    println(stu1.id)
    stu1.id = "1000"
    println(stu1.id)
  }
}

4、apply （伴生对象）

在定义类的时候，可以定义 apply 方法
作用是直接可以通过类名（属性）直接返回一个当前属性的类对象（省个 new）
样例类中已定义好，可以直接使用

package day65


object ScalaDemo6{

  def main(args: Array[String]): Unit = {

    val aa = new AA("1001")
    val bb = new BB("1002")

    // apply 方法，可以通过调用类名默认调用
    // 创建时系统也默认写为对象的创建
    val bb2 = BB("1003")
  }

}

class AA(id:String) {
  val _id = id
}

class BB(id:String){
  val _id = id
}

// 该类称为 BB 的伴生对象
object BB {
  def apply(id: String): BB = new BB(id)
}

三、面向函数


1、函数定义

package day65


object test {

  // scala 允许一个文件中包含多个main方法
  // 调用方法尽可能在main方法的内部，
  // 否则会先运行main方法外的函数调用
  // 同一文件夹下不能有同名的 object

  def main(args: Array[String]): Unit = {

    def a(): Unit = {
      println("a")
    }
    a()
  }

  def b(): Unit = {
    println("b")
  }
  b()
}


object ScalaDemo7 {
  /*
   * 函数（方法）可以定义在什么位置？
   * 类中、Object中、方法中
   */

  def main(args: Array[String]): Unit = {

    /*
         def 这是一个函数
         func1 函数名
         str1: String, str2: String 函数的参数
         Unit: 函数的返回值类型，这里相当于void
         {} : 方法体
         等号别忘了
     */
    def fun1(str1: String, str: String): Unit = {
      print("fgh")
    }

    def fun2(int: Int): Int = {
      return int + 1
    }

    // 1、有返回值的函数，不写 return 默认返回最后一行
    def fun3(int: Int): Int = {
      int + 1
    }

    // 2、只有一行代码的函数，{}可以省略
    def fun4(int: Int): Int = int + 1

    // 3、程序会推断返回值的类型，可以省略
    def fun5(int: Int) = int + 1

    // 4、倘若函数没有参数列表，那么括号也可以省略
    // 虽然很怪，但是他是一个没有参数的函数
    def fun6 = 1 + 1

	println(fun1("fgh","fgh"))
    println(fun2(1))
    println(fun3(1))
    println(fun4(1))
    println(fun5(1))
    println(fun6)
  }
}

2、函数式编程 — 函数作为参数

package day65

object ScalaDemo8 {

  /*
        函数式编程（高阶函数、面向函数编程）

        面向对象编程：把对象传来传去
        注意：对象作为 参数 和 返回值 的时候有类型的限制

        面向函数编程：把函数传来传去
        注意：函数作为 参数 和 返回值 的时候也有类型的限制

        函数式编程的分类：
        1、以函数作为参数
        2、以函数作为返回值

        如何描述一个函数fun

        参数类型 => 返回值类型
   */

  def main(args: Array[String]): Unit = {

    // 此处是将函数作为参数进行传参
    // 而不是进行调用，因此不能加括号！
    println(fun2S(fun2))

    // 调用匿名函数
    println(funX("1", 1))


    // 使用匿名函数来传参 fun: String => Int
    println(fun2S((str: String) => {
      str.toInt + 1
    }))

    // 1、函数体只有一行代码，花括号可以省略
    println(fun2S((str: String) => str.toInt + 1))

    // 2、如果匿名函数作为另一个函数的参数传入 参数的类型可以省略
    println(fun2S(str => str.toInt + 1))

    // 3、如果参数只被使用的一次 则可以省略 并用下划线_替代
    println(fun2S(_.toInt + 1))

  }

  def fun1(int: Int): Int = int + 1
  def fun2(str: String): Int = str.toInt + 1
  
  // 这个函数的参数就是一个函数
  // 其形参需要是String 返回值需要是Int (可以是他们的父类)
  def fun2S(fun: String => Int): Int = {

    val i = fun("100")
    // 默认返回最后一行
    i
  }

  // 匿名函数
  // => 左边是参数列表记得加小括号，右边是{方法体}
  (str: String, int: Int) => {
    str.toInt + int
  }

  // 也可以用一个变量去接收
  val funX: (String, Int) => Int = (str: String, int: Int) => {
    str.toInt + int
  }
}

3、函数式编程的一些小小引用参观

用 Scala 自带的遍历数组的方式进行演示

package day65

object ScalaDemo9 {

  def main(args: Array[String]): Unit = {

    // 创建数组
    val arr: Array[Int] = Array[Int](1,2,3)

    // 遍历输出
    // 方法一
    var i:Int = 0
    while (i < arr.length){
      // scala 中下标用小括号
      println(arr(i))
      i += 1
    }

    // 方法二
    // foreach方法：需要传入一个函数f：
    //            参数类型为Int，返回值类型为Unit
    // foreach方法会将array中的每一个元素依次作为参数传递给函数f
    // println是一个函数：参数类型为Any，返回值类型为Unit
    // 这里就是将数组中的每一个Int ,传入到 println 当中，多态

    // Any是任意类型的基类
    // AnyRef：任意引用类型的基类
    // AnyVal：任意值类型的基类
    arr.foreach(println)

    // 方法三
    for (elem <- arr) {
      println(elem)
    }

//    // 方法四
//    for(i <- 0 to arr.length - 1){
//      println(arr(i))
//    }
//
//    for(i <- 0 until arr.length){
//      println(arr(i))
//    }
//
//    for(i <- Range(0,arr.length)){
//      println(arr(i))
//    }

    // 将数组中每个元素翻倍
    // 方法一 在循环中挨个 * 2
    def double(int: Int): Unit = int * 2

    arr.foreach(double)

    // mkString 类似 Python 中的 join
    // 能够将容器中的元素按照指定分隔符进行拼接
    println(arr.mkString(","))

    // 问题是 foreach 没有返回值，无法得到翻倍后的数组
    // 这里可以使用 map 方法，和 foreach 的唯一区别是有返回值

    def double2(int: Int):Int = int * 2

    // 会返回一个新对象
    val arr2: Array[Int] = arr.map(double2)
    println(arr2.mkString(","))

    // 也可以使用匿名函数
    arr.map( int=>int * 2)
    println(arr.map(_ * 2).mkString(","))
  }
}

4、函数式编程 — 函数作为返回值

package day65


object ScalaDemo10 {

  def main(args: Array[String]): Unit = {

    val f1 = fun1(1)
    val str = f1(1)
    println(str)

    // 也可以一步到位
    println(fun1(1)(1))

    pow1(2,5)

    // 固定参数，底数相同，运算不同次幂
    val a_2: Int => Unit = pow2(2)
    a_2(1)
    a_2(2)
    a_2(3)
  }

  // 以函数作为返回值时 返回值类型需要手动指定
  def fun1(int: Int): Int => String = {

    def fun2(int: Int): String = {
      val str: String = "fgh"
      // 对应fun2 :String
      str
    }
    // 对应fun1 :Int => String
    fun2
  }

  // 两个参数的函数
  def fun3(int1: Int,int2: Int)={
    println("fgh")
  }

  // 柯里化
  // 像是将参数拆开，能够将原本一个函数拆成N个
  // 特定场合可以用来固定参数
  def fun4(int1: Int)(int2: Int)={
      println("fgh")
  }

  // 幂运算
  // 方法一 可以使用默认参数
  def pow1(a: Int,b: Int =2)={
    println(Math.pow(a,b))
  }

  // 方法二
  def pow2(a:Int)(b:Int)={
    println(Math.pow(a,b))
  }
}

零碎

Scala 经过反编译后，会成为一个 Java 函数
并且变量会被反编译为函数

Any是任意类型的基类
AnyRef：任意引用类型的基类
AnyVal：任意值类型的基类
Nothing 无参数
B 任意类型返回值
Unit 无返回值
GenTraversable 容器

Any 是所有类的父类（一个始祖的概念）
Nothing 是所有类的子类（一个倒霉孙子的概念）

foreach 无返回值
map 有返回值

韭菜盒子123
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Scala面向对象.docx
04-05
Scala面向对象
Scala 【 8 面向对象编程 – 继承 】
01-20
面向对象编程 – 继承 复用 ~ 可扩展性 ~ 可维护性 extends 使用 extends 关键字表示继承。 继承就代表，子类可以从父类继承父类的 field 和 method 。子类可以在自己内部放入父类所没有的子类特有的 field 和 ...
Scala数据类型转换
热门推荐
Fortuna_i的博客
03-05 1万+
Scala中类似java数据类型转换的简单方法： var name = 1 1. name.toDouble 使用toDouble、toInt等方法，对象名.to方法可以实现简单的数据类型转换。 2.name.doubleValue 可以使用doubleValue、longValue、intValue三种方法，用于简单的数据类型转换。 3.Integer.valueOf（name） ...
String.valueOf() 方法的使用
weixin_30585437的博客
11-04 361
1. 由 基本数据型态转换成 String String 类别中已经提供了将基本数据型态转换成 String 的 static 方法 也就是 String.valueOf() 这个参数多载的方法 有下列几种 String.valueOf(boolean b) : 将 boolean 变量 b 转换成字符串 String.valueOf(char c) : 将 char 变量 c 转换成字符串 St...
Scala——面向对象和函数式编程语言
weixin_30756499的博客
12-06 386
Scala Scala是一门运行时基于JVM的编程语言，具备函数式编程和面向对象特点。 基本知识 basics 任意词均可作为符号名，对于关键词，以反引号包裹，避免使用下划线，避免带美元符的名字。 声明类型为Type的符号x的方式是先给出符号后通过冒号指定类型，x:Type，不同于java/c++等语言的Type x形式。 变量声明 variable/constant declarati...
scala函数式编程系列（六）--- scala面向对象
qq_824203453_的博客
07-15 4204
  版权声明：本文为博主原创文章，未经博主允许不得转载!! 欢迎访问:https://blog.csdn.net/qq_21439395/article/details/81057459 交流QQ: 824203453   1. 面向对象 Scala的类与Java、C++的类比起来更简洁，学完之后你会更爱Scala！！！ 对象： 使用object关键字修饰的 类： 使用class关...
Scala语言：集成面向对象和函数式编程的特性
xidajiancun
12-11 445
简介 Scala编程语言近来抓住了很多开发者的眼球。如果你粗略浏览Scala的网站，你会觉得Scala是一种纯粹的面向对象编程语言，而又无缝地结合了命令式和函数式的编程风格。Christopher Diggins认为： 不太久之前编程语言还可以毫无疑义地归类成“命令式”或者“函数式”。Scala代表了一个新的语言品种，它抹平了这些人为划分的界限。 根据David Rupp在博客中的说法，...
Scala 【 6 面向对象编程 】
01-07
scala – 面向对象编程 定义类来说不需要修饰，直接使用 class 创建即可。 class HelloWorld{ private var name = Li def sayHello(){ print(Hello, + + name) } // 不加括号的方法调用时也不能加 def getName...
Scala面向对象编程课件.rar
03-09
Scala面向对象编程课件.rar
17面向对象
01-07
scala语言是一门面向函数编程的语言, 并且兼容面向对象的思想 Scala中类分为两种：描述类class，执行类object。 类不需要使用public修饰，一个文件可存在多个类。 2.创建类 class Student{ //var修饰的属性相当于...
Scala —— 结合面向对象和函数式编程的简洁语言 —— 入门基础知识
奇妙的代码
03-24 231
Scala将面向对象和函数式编程结合在一种简洁的高级语言中。Scala的静态类型有助于避免复杂应用程序中的bug，它的JVM允许您构建高性能系统，并可以轻松访问庞大的库生态系统。
Scala:字符串
皮皮blog
10-23 4025
http://blog.csdn.net/pipisorry/article/details/52902348Scala字符串在 Scala 中，字符串的类型实际上是 Java String，它本身没有 String 类。在 Scala 中，String 是一个不可变的对象，所以该对象不可被修改。这就意味着你如果修改字符串就会产生一个新的字符串对象。但其他对象，如数组就是可变的对象。创建字符串创建
Scala语法教程
weixin_51497782的博客
02-17 1843
Scala详细的语法教程，非常细致
Scala（二）之“数值”
GnahzNib的博客
08-29 4670
Scala中所有的数值都是对象，包括Byte、Char、Double、Float、Int、Long和Shart。与被称为“非数值类型”的Unit和Boolean一样，这些数值类型都继承扩展自AnyVal特质（trait） 数据类型的精确范围值得查看：scala> Short.MinValue res45: Short = -32768scala> Short.MaxValue res46: Shor
十二.Scala字符串
david's Blog
04-25 2470
Scala 字符串以下实例将字符串赋值给一个常量：object TestString1 { val greeting: String = "Hello,World!" def main(args: Array[String]) { println( greeting ) } }以上实例定义了变量 greeting，为字符串常量，它的类型为 String (java.lan
面向过程，面向对象，面向函数三种编程思想的理解
qq_41022872的博客
11-29 1974
面向过程，面向对象，面向函数编程的理解 // 1. 面向过程 // 面向过程将编程任务当作完成一件事情，这件事情需要按步骤完成。比如说，煮咖啡这件事：先拿一定量的咖啡豆，然后磨成粉末，再倒入咖啡机，等待几分钟，就煮好了咖啡。这就是面向过程。代码体现： console.log('取咖啡豆'); console.log('磨成粉末'); console.log('煮开水'); console.log(...
scala不使用str.toLong/Integer.valueOf()/Integer.parseInt()等内置方法将字符串"123456" 转化成数字123456（两种方法）
墨殇
06-12 1362
前言：怎么说呢，这个其实是一道面试题，所以分享给大家并方便自己以后翻阅（哎~毕竟忘性太大） 方法一（java传统思想）： object HomeWorkTest { def main(args: Array[String]) { var strInt = 0 //定义一个可变的整型用来接收转换后的数字 val str = "123456" //定义一个不可变的数字字...
07_for循环返回值&while循环
m0_52474839的博客
04-28 1051
scala中没有break，continue原因是其不是面向对象的，也可以用其他语法代替。break使用面向方式代替，底层抛出for循环异常，外层捕获异常。continue使用if else代替。for循环返回值是Unit。原因是防止产生歧义；
10_Scala控制抽象*了解
最新发布
m0_52474839的博客
04-29 478
抽象函数-> 函数没有输入只有返回 ->抽象方法的调用时候，不能有小括号。
scala 是完全面向对象的语言吗
06-10
Scala 是一种混合了函数式编程和面向对象编程的编程语言。尽管 Scala 支持面向对象编程，但它并不是一种完全的面向对象编程语言。 Scala 中的函数是一等公民，可以像其他数据类型一样进行传递和操作。Scala 还支持...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值