Scala 语法入门

Scala语法入门

- 1. 定义变量
- 2. 定义方法
- 3. 闭包
- 4. 声明字符串
- 5. 声明数组
- 6. 声明集合
- 7. 异常处理

1. 定义变量

（变量的类型在变量名之后等号之前声明）

不可变变量(val)
类似于 Java 中的 final 变量，即一旦赋值后，其值不能再被改变。
```
scala">val myVal : String = "Foo"
```
可变变量(var)
类似于 Java 中的普通变量，其值可以在程序的生命周期内多次改变。
```
scala">var myVar : String = "Foo"
```

在 Scala 中声明变量和常量不一定要指明数据类型，在没有指明数据类型的情况下，其数据类型是通过变量或常量的初始值推断出来的。
所以，如果在没有指明数据类型的情况下声明变量或常量必须要给出其初始值，否则将会报错。

scala">val inferredInt = 42  // 编译器推断为 Int
val inferredDouble = 3.14  // 编译器推断为 Double
val inferredString = "Hello, Scala!"  // 编译器推断为 String
val inferredBoolean = true  // 编译器推断为 Boolean

多个变量声明
Scala 中，可以使用逗号分隔、元组解构和 for 推导式等方法同时声明多个变量。

逗号分隔

scala">val a, b, c: Int = 5
var x, y, z: Int = 10

for 推导式

scala">object ForComprehension {
  def main(args: Array[String]): Unit = {
    // 同时声明多个变量用于迭代
    val numbers = List((1, "one"), (2, "two"), (3, "three"))
    for ((number, word) <- numbers) {
      println(s"Number: $number, Word: $word")
    }

    // 使用 for 推导式生成新集合
    val newNumbers = for {
      (number, word) <- numbers
    } yield (number * 2, word.toUpperCase)

    println(s"New Numbers: $newNumbers")
  }
}

2. 定义方法

格式

def functionName ([参数列表]) : [return type] = {
   function body
   return [expr]
}

案例

scala">object add{
   def addInt( a:Int, b:Int ) : Int = {
      var sum:Int = 0
      sum = a + b

      return sum
   }
}

如果方法没有返回值，可以返回为 Unit，类似于 Java 的 void。

（定义函数，也可认为方法和函数没区别）

scala">class Test{
  def m(x: Int) = x + 3
  val f = (x: Int) => x + 3
}

3. 闭包

闭包是指一个函数可以捕获外部变量，并在其作用域之外仍然可以使用这些变量。
简单形式

scala">object ClosureExample1 {
  def main(args: Array[String]): Unit = {
    var externalVar = 10

    val closure = (x: Int) => x + externalVar

    println(closure(5))  // 输出 15

    externalVar = 20

    println(closure(5))  // 输出 25
  }
}

复杂形式：闭包作为返回值

scala">object ClosureExample2 {
  def main(args: Array[String]): Unit = {
    def makeAdder(adder: Int): Int => Int = {
      (x: Int) => x + adder
    }

    val addFive = makeAdder(5)
    val addTen = makeAdder(10)

    println(addFive(3))  // 输出 8
    println(addTen(3))   // 输出 13
  }
}

详细解释
makeAdder 是一个高阶函数，它接收一个整数 adder，返回一个函数。
返回值类型：Int => Int（表示返回一个输入 Int，返回 Int 的函数）。
返回的函数 (x: Int) => x + adder：

这是一个匿名函数（Lambda 表达式）。

执行过程总结

步骤	代码	解释
①	makeAdder(5)	adder = 5，返回 (x: Int) => x + 5
②	val addFive = makeAdder(5)	addFive 现在是 (x: Int) => x + 5
③	println(addFive(3))	3 + 5 = 8，输出 8

闭包与函数式编程：
闭包在函数式编程中是一个重要的概念，广泛用于高阶函数、柯里化等技术中。
以下实例，highOrderFunction 函数接受一个函数作为参数。传递的闭包捕获了外部变量 externalVar。

scala">object ClosureExample4 {
  def main(args: Array[String]): Unit = {
    def highOrderFunction(f: Int => Int, x: Int): Int = f(x)

    val externalVar = 5
    val closure = (x: Int) => x + externalVar

    println(highOrderFunction(closure, 10))  // 输出 15
  }
}

4. 声明字符串

scala">val s = "Hello World!";

或

val s:String = "Hello World!";

5. 声明数组

scala">var arr:Array[String] = new Array[String](3)

或

var arr = new Array[String](3)

或

var arr = Array("Runoob", "Baidu", "Google")

为数组元素赋值

scala">arr(0) = "Runoob"

6. 声明集合

scala">// 定义整型 List
val x = List(1,2,3,4)

// 定义 Set
val x = Set(1,3,5,7)

// 定义 Map
val x = Map("one" -> 1, "two" -> 2, "three" -> 3)

// 创建两个不同类型元素的元组
val x = (10, "Runoob")

// 定义 Option
val x:Option[Int] = Some(5)

7. 异常处理

scala">import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOException

object Test {
   def main(args: Array[String]) {
      try {
         val f = new FileReader("input.txt")
      } catch {
         case ex: FileNotFoundException => {
            println("Missing file exception")
         }
         case ex: IOException => {
            println("IO Exception")
         }
      } finally {
         println("Exiting finally...")
      }
   }
}