Scala 基础（1）—— 定义变量 & 定义函数

1. 使用 val & var 定义变量

Scala 中的变量被分为2种：val 和 var。其含义于 Java 中的 final 关键字类似。

val 等同于被 final 修饰过的变量， 即一旦初始化便不可被重新赋值。

var 等同于未被 final 修饰过的变量，可以被重新赋值。

1   def main(args: Array[String]): Unit = {
2     val x = 1
3     x = 2 // 编译错误
4   }

 

1   def main(args: Array[String]): Unit = {
2     var x = 1
3     x = 2 // 编译成功
4   }

 

与 Java 相同，这里的所谓不变性，是指引用不可变但是引用对象的状态却是可变的。

object Demo {

  def main(args: Array[String]): Unit = {
    val a = new A(1)
    a.x = 3
    println(a.x)
  }
}

class A(myX: Int) {
  var x: Int = myX
}

以上的例子，输出结果为3。

 

 

2. 类型推断

可以看出这里有一个很明显的与 Java 不同的地方：在声明变量的时候，没有显式地给出类型

Scala 支持类型推断，就是它能够根据等式右侧的值来推断出这个参数的类型，例如上面的例子，x 的类型就是 scala.Int。

如果这并不是你所希望的 x 类型，例如，你期望初始化一个 Double 类型的，可以这么定义：

val x: Double = 1

 

需要注意的是，如果只希望声明变量，而不同时对变量进行初始化（一般来说这种情况只存在于定义成员变量），那么就必须显式定义类型，因为没有等式右侧去推测这个参数的实际类型。

abstract class MyClass {
  val y: Int
}

 

 

3. 强调参数可变性的意义

Scala 之所以使用 val 和 var 来定义参数，主要就是为了在声明变量时，就确定它的可变性。

Scala 推荐能使用 val 的地方就是用 val，这么做的优势有：

• Scala 是一门支持函数式编程的语言，将变量定义成 val，可以有效地规避/减少函数的副作用。
• 将成员变量定义成 val，可以保证构造的对象是不可变对象，这个性质在多线程编程中很有用。

关于不可变对象，可以参考《Java 并发编程实战》P38（因为 Scala 是运行在 JVM 平台上的，编译之后本质其实就是 Java 的字节码文件）

当满足以下条件时，独享才是不可变的：

• 对象创建以后其状态就不能改变。
• 对象的所有域都是 final 类型的。
• 对象是正确创建的（在对象创建期间，this 引用没有溢出）。

 

 

4. 使用 def 定义函数

我们观察以下函数的定义：

  def max(x: Int, y: Int): Int = {
    if (x > y) x else y
  }

 

定义一个函数包括以下部分：

• def -> 定义函数的关键字
• max -> 函数名
• x: Int, y: Int -> 参数列表
• Int -> 函数的结果类型
• if (x > y) x else y -> 函数体

 

 

5. 函数的结果类型

由于 Scala 的类型推断机制，函数的结果类型是可以省略的，也就是说没这么定义函数也是可行的：

  def max(x: Int, y: Int) = {
    if (x > y) x else y
  }

 

但是，有一种例外，就是递归地函数，必须给出结果类型：

  def factorial(x: Int) = {
    require(x >= 0)
    if (x > 1) x * factorial(x - 1) else 1 // 编译错误
  }

虽然如此，但是一般推荐所有可以被外部访问的函数（等价于 Java 中的 public），都显式地加上结果类型。　

 

在上面 main 函数的例子中，结果类型 Unit 等价于 Java 中的 Void，表示函数并不会返回有实际意义的结果。

 

转载于:https://www.cnblogs.com/jing-an-feng-shao/p/10126422.html