Scala 入门

1. Scala 简介

Scala 是一门多范式（multi-paradigm）的编程语言，设计初衷是要集成面向对象编程和函数式编程的各种特性。

Scala 运行在 Java 虚拟机上，并兼容现有的 Java 程序。

Scala 源代码被编译成 Java 字节码，所以它可以运行于 JVM 之上，并可以调用现有的 Java 类库。

官网: https://scala-lang.org/

2. 开发环境

IDEA + Scala plugin

3. 基本语法

基本语法和Java 差不多但是都加入了更加函数式的写法
基本数据类型和Java是一致的
变量声明的方式有点像JavaScript, 但Sacla和Java一样是强类型的

object Start {
  def main(args: Array[String]): Unit = {
    test4()
  }

  /**
   * 变量和值
   */
  def testVarVal(): Unit = {
    // 变量申明
    //var VariableName : DataType [=  Initial Value]
    //或 常量申明
    //val VariableName : DataType [=  Initial Value]
    var variable: String = "变量";
    val value: String = "常量";
    val xmax, ymax = 100 // xmax, ymax都声明为100
    println(variable)
    println(value)
    println("hello Quanwei")
  }

  def test1(): Unit = {
    //Scala 访问修饰符有：private，protected，public。
    //如果没有指定访问修饰符，默认情况下，Scala 对象的访问级别都是 public。
    //Scala 中的 private 限定符，比 Java 更严格，在嵌套类情况下，外层类甚至不能访问被嵌套类的私有成员。
  }

  def test2(): Unit = {

  }

  /**
   * 分支语句 可以返回值
   */
  def test3(): Unit = {
    val age = 10;
    val result: String = if (age <= 6) {
      "ASD"
    } else if (age <= 10) {
      "sda"
    } else {
      "aaf"
    }
    println(result)
  }

  /**
   * 循环
   * <pre>
   * for( var x <- Range ){
   * statement(s);
   * }
   * </pre>
   */
  def test4(): Unit = {
    for (i <- 0 to 10) // to 是1的方法调用相当于 1.to(10)
      print(i + " ")
    println()

    for (i <- 0 until 10)
      print(i + " ")
    println()

    (1 to 10).foreach(x => print(x + " "))
    println()

    for (i <- Array(1, 2, 3, 4, 123, 12, 4, 12, 412, 41, 24, 31))
      print("->" + i)

    println()
    // 循环守卫 为true进入循环
    println("循环守卫 为true进入循环")
    for (i <- 1 to 20 if (i & 1) != 0)
      print(i + " ")

    // 循环步长
    println("\n循环步长")
    for (i <- 1 to 32 by 3) {
      print(i + " ")
    }
    println("\n循环嵌套")
    for (i <- 1 to 3; j <- 1 to 3) {
      print("(i: " + i + ", j: " + j + ")\n")
    }
    println("\n循环嵌套, 引入变量")
    for (i <- 1 to 3; j = 4 - i) {
      print("(i: " + i + ", j: " + j + ")\n")
    }
    println("\n循环返回值")
    val res = for (i <- 1 to 3) yield i * i
    println("res: " + res)
    
  }
}

4. 基本函数式

package lang

object Functional {
  /**
   * 1.return可以省略，Scala会使用函数体的最后一行代码作为返回值
   * 2.如果函数体只有一行代码，可以省略花括号
   * 3.返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）
   * 4.如果有return，则不能省略返回值类型，必须指定
   * 5.如果函数明确声明unit，那么即使函数体中使用return关键字也不起作用
   * 6.Scala如果期望是无返回值类型，可以省略等号   这种形式称为过程
   * 7.如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加
   * 8.如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略
   * 9.如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略
   *
   * @param args args
   */
  def main(args: Array[String]): Unit = {
    def quanweiSay(): Unit = {
      println("Hi Function")
    }

    quanweiSay()
    Functional.quanweiSay()
    Functional.quanweiSay("Quanwei")
    Functional.quanweiSay(name = "Quanwei")
    Functional.quanweiSay("Quanwei", "Tang")
    call(Functional.quanweiSay)
    p("Tang Quanwei")
    val qr = q()
    println(qr)
  }

  val p: Any => Unit = x => println(x)
  val q: () => Unit = () => println

  def quanweiSay(): Unit = {
    println("Hi Method")
  }

  def quanweiSay(name: String): String = {
    println("Hi " + name)
    return name
  }

  /**
   * 可变参数
   * 默认参数
   * 带名传参
   *
   * @param names
   * @return
   */
  def quanweiSay(names: String*): Seq[String] = {
    println("Hi " + names)
    return names
  }

  def call(func: String => Unit): Unit = {
    func("Alice")
  }
}