在浏览器中运行 Scala
表达式
表达式是可计算的语句。
你可以使用 println 输出表达式的值。
println(1) // 1
println(1+1) // 2
println("Hello!") // Hello!
println("Hello," + " world!") // Hello, world!
值
使用 val 关键字来命名表达式的值。
val x = 1 + 1
println(x) // 2
这里的命名结果, 例如 x, 叫做值。引用一个值不会重新计算它。
值一旦确定就不能被重新赋值。
val x = 1+1
x = 3 // This does not compile.
值的类型可以被推断出来, 但是你也可以显式的声明它的类型, 像这样:
val x: Int = 1 + 1
变量
变量像值一样, 但是你可以给它重新赋值。用 var 关键字来定义一个变量。
var x = 1 + 1
x = 3 // This compiles because "x" is declared with the "var" keyword.
println(x * x) // 9
像值那样, 你可以显式地声明变量的类型:
var x: Int = 1 + 1
Blocks
用 {} 把多个表达式组合起来。我们把这个 {} 叫做 block. block 中的最后一个表达式的结果也是整个 block 的结果。
println({
val x = 1 + 1
x + 1
}) // 3
函数
函数是接受参数的表达式。你可以定义一个返回给定的整数加 1 的函数:
(x: Int) => x + 1
=> 的左边是参数列表, 右边是引用该参数的表达式。你也可以给这个函数起个名字:
val addOne = (x: Int) => x + 1
println(addOne(1)) // 2
函数可以接收多个参数.
val add = (x: Int, y:Int) => x + y
println(add(1,2)) // 3
或者函数也可以不接收参数:
val getTheAnswer = () => 42
println(getTheAnswer()) // 42
我们会在稍后深入讲解它。
方法
方法使用 def 关键字来定义。
def add(x: Int, y:Int):Int = x + y
println(add(1,2)) // 3
方法不能使用 val 或 var 关键字来命名。
def add(x: Int, y:Int): Int = x + y
val add2 = add // 这不会编译
var add3 = add // 这也不会编译
方法可以接收多个参数列表.
def addThenMultiply(x: Int, y: Int)(multiplier: Int): Int = (x + y) * multiplier
println(addThenMultiply(1, 2)(3)) // 9
或者不接收任何参数：
def name: String = System.getProperty("name")
println("Hello, " + name + "!")
类
使用 class 关键字来定义类。
class Greeter(prefix: String, suffix: String) {
def greet(name: String): Unit =
println(prefix + name + suffix)
}
你可以使用 new 关键字来实例化一个类.
val greeter = new Greeter("Hello, ", "!")
greeter.greet("Scala developer") // Hello, Scala developer!
Case Classes
Scala 有一种叫做 「case」的特殊类。默认地, case 类是不可变的和按值比较的。你可以使用 case class 关键字来定义 case class。
case class Point(x: Int, y: Int)
你不用 new 关键字就可以实例化 case class.
val point = Point(1, 2)
val anotherPoint = Point(1, 2)
val yetAnotherPoint = Point(2, 2)
并且它们是按值比较的:
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 关键字来定义对象。
object IdFactory {
private var counter = 0
def create(): Int = {
counter += 1
counter
}
}
通过引用对象的名字来访问这个对象。
val newId: Int = IdFactory.create()
println(newId) // 1
val newerId: Int = IdFactory.create()
println(newerId) // 2
我们会在之后深入讨论它。
Traits
Traits 是包含特定字段和方法的类型。 可以组合多个 traits。
您可以使用 trait 关键字定义 traits。
trait Greeter {
def greet(name: Stirng): Unit
}
Traits 也可以拥有默认的实现。
trait Greeter {
def greet(name: String): Unit =
println("Hello, " + name + "!")
}
你可以使用 extends 关键字扩展 traits 并使用 override 关键字重写 traits 的实现。
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 方法：
object Main {
def main(args: Array[String]): Unit =
println("Hello, Scala developer!")
}
