Scala 基础

在浏览器中运行 Scala

scalafiddle.io

表达式

表达式是可计算的语句。

你可以使用 println 输出表达式的值。

1
2
3
4
println(1) // 1
println(1+1) // 2
println("Hello!") // Hello!
println("Hello," + " world!") // Hello, world!

使用 val 关键字来命名表达式的值。

1
2
val x = 1 + 1
println(x) // 2

这里的命名结果, 例如 x, 叫做值。引用一个值不会重新计算它。
值一旦确定就不能被重新赋值。

1
2
val x = 1+1
x = 3 // This does not compile.

值的类型可以被推断出来, 但是你也可以显式的声明它的类型, 像这样:

1
val x: Int = 1 + 1

变量

变量像值一样, 但是你可以给它重新赋值。用 var 关键字来定义一个变量。

1
2
3
var x = 1 + 1
x = 3 // This compiles because "x" is declared with the "var" keyword.
println(x * x) // 9

像值那样, 你可以显式地声明变量的类型:

1
var x: Int = 1 + 1

Blocks

{} 把多个表达式组合起来。我们把这个 {} 叫做 block. block 中的最后一个表达式的结果也是整个 block 的结果。

1
2
3
4
println({
val x = 1 + 1
x + 1
}) // 3

函数

函数是接受参数的表达式。你可以定义一个返回给定的整数加 1 的函数:

1
(x: Int) => x + 1

=> 的左边是参数列表, 右边是引用该参数的表达式。你也可以给这个函数起个名字:

1
2
val addOne = (x: Int) => x + 1
println(addOne(1)) // 2

函数可以接收多个参数.

1
2
val add = (x: Int, y:Int) => x + y
println(add(1,2)) // 3

或者函数也可以不接收参数:

1
2
val getTheAnswer = () => 42
println(getTheAnswer()) // 42

我们会在稍后深入讲解它。

方法

方法使用 def 关键字来定义。

1
2
def add(x: Int, y:Int):Int = x + y
println(add(1,2)) // 3

方法不能使用 valvar 关键字来命名。

1
2
3
def add(x: Int, y:Int): Int = x + y
val add2 = add // 这不会编译
var add3 = add // 这也不会编译

方法可以接收多个参数列表.

1
2
def addThenMultiply(x: Int, y: Int)(multiplier: Int): Int = (x + y) * multiplier
println(addThenMultiply(1, 2)(3)) // 9

或者不接收任何参数:

1
2
def name: String = System.getProperty("name")
println("Hello, " + name + "!")

使用 class 关键字来定义类。

1
2
3
4
class Greeter(prefix: String, suffix: String) {
def greet(name: String): Unit =
println(prefix + name + suffix)
}

你可以使用 new 关键字来实例化一个类.

1
2
val greeter = new Greeter("Hello, ", "!")
greeter.greet("Scala developer") // Hello, Scala developer!

Case Classes

Scala 有一种叫做 「case」的特殊类。默认地, case 类是不可变的和按值比较的。你可以使用 case class 关键字来定义 case class。

1
case class Point(x: Int, y: Int)

你不用 new 关键字就可以实例化 case class.

1
2
3
val point = Point(1, 2)
val anotherPoint = Point(1, 2)
val yetAnotherPoint = Point(2, 2)

并且它们是按值比较的:

1
2
3
4
5
6
7
8
9
10
11
12
13
if (point == anotherPoint) {
println(point + " and " + anotherPoint + " are the same.")
} else {
println(point + " and " + anotherPoint + " are different.")
}

// Point(1,2) and Point(1,2) are the same.
if (point == yetAnotherPoint) {
println(point + " and " + yetAnotherPoint + " are the same.")
} else {
println(point + " and " + yetAnotherPoint + " are different.")
}
// Point(1,2) and Point(2,2) are different.

我们还想介绍更多的 case class, 我们确定你会爱上它! 我们会在之后深入了解它。

对象

对象是它们自身定义的单个实例。你可以把它们当作它们自身类的单例。
你可以使用 object 关键字来定义对象。

1
2
3
4
5
6
7
object IdFactory {
private var counter = 0
def create(): Int = {
counter += 1
counter
}
}

通过引用对象的名字来访问这个对象。

1
2
3
4
val newId: Int = IdFactory.create()
println(newId) // 1
val newerId: Int = IdFactory.create()
println(newerId) // 2

我们会在之后深入讨论它。

Traits

Traits 是包含特定字段和方法的类型。 可以组合多个 traits。

您可以使用 trait 关键字定义 traits。

1
2
3
trait Greeter {
def greet(name: Stirng): Unit
}

Traits 也可以拥有默认的实现。

1
2
3
4
trait Greeter {
def greet(name: String): Unit =
println("Hello, " + name + "!")
}

你可以使用 extends 关键字扩展 traits 并使用 override 关键字重写 traits 的实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class DefaultGreeter extends Greeter

class CustomizableGreeter(prefix: String, postfix: String)
extends Greeter {
override def greet(name: String):Unit = {
println(prefix + name + postfix)
}
}

val greeter = new DefaultGreeter()
greeter.greet("Scala developer") // Hello, Scala developer!

val customGreeter = new CustomizeGreeter("How are you, ", "?")
customGreter.greet("Scala developer") // How are you, Scala developer?

这里, DefaultGreeter 只扩展单个 trait, 但是它可以扩展多个 traits。我们会在稍后深入讨论 traits。

Main 方法

main 方法是程序的入口点。 Java 虚拟机需要一个命名为 main 的 main 方法,并接受一个参数,即一个字符串数组。

使用 object,可以如下定义 main 方法:

1
2
3
4
object Main {
def main(args: Array[String]): Unit =
println("Hello, Scala developer!")
}