Scala之旅（TOUR OF SCALA）——基础（BASICS）

在浏览器中尝试 Scala 编程

你可以使用在浏览器使用 ScalaFiddle 运行 Scala 程序。

1. 点击前往 https://scalafiddle.io。
2. 在左边的面板中粘贴 println("Hello, World!")。
3. 点击左上角的“Run”按钮，右边的面板中会输出结果。

这是一个简单的，零基础的运行 Scala 代码的方式。

在文档中有很多例子都是集成了 ScalaFiddle 插件，所以可以简单的直接点击Run按钮运行。

表达式 （Expressions）

表达式是可以计算的语句。

1 + 1

你可以使用 println 函数来输出表达式的结果。

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

常量 （Values）

你可以使用一个用 val 关键字来命名表达式的结果。

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

命名的结果，像上例中的 x ，被称为常量（Values）。指向一个不能再次计算的值。

常量不能被再次赋值。

val x = 1 + 1
x = 3 // 不能通过编译

常量的类型可以被推断出来，但是你也可以明确的写出类型，像下面这样：

val x: Int = 1 + 1

注意声明类型 Int 在常量名 x 之后。而且需要一个 :。

变量 （Variables）

变量很像常量，除了你可以重新赋值。你可以使用关键字 var 来声明和定义一个变量。

var x = 1 + 1
x = 3 // 可以通过编译，因为 “x” 使用 “var” 关键字进行声明

与常量相同，如果你需要，你也可以明确地写出类型。

var x: Int = 1 + 1

块 （Blocks）

你可以将很多表达式使用 {} 放在一起。我们称为块。

在块中最后一个表达式的结果也将是整个块的结果。

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

函数 （Functions）

函数是带有参数的表达式集合。

你可以定义一个匿名函数（没有名称），返回加一之后的参数。

(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

方法 （Method）

方法无论是结构还是行为都和函数非常像，但是他们之间还是有一些非常关键的不同点。

方法使用关键字 def 定义。def 关键字之后是方法名，参数列表，返回类型和方法体。

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

注意：返回类型在参数列表之后使用一个冒号加类型声明 : Int。

方法可以有多个参数列表。

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

或者根本没有参数列表。

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

这就是他们的一些不同点，但是对于目前来说，你可以认为方法与函数是相似的。

方法的方法体可以有多行。

def getSquareString(input: Double): String = {
    val square = input * input
    square.toString
}

方法体最后一行表达式的值是方法的返回值。（Scala是有 return 关键字的，但是不常用）

类 （Classes）

你可以使用关键字 class 定义类，之后紧接类名的构造器的参数。

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

类中方法 greet 的返回类型为 Unit ，意思是没有意义的返回值。与 Java 和 C 中的 void 类型很像。（一个不同是因为每一个 Scala 表达式必须有返回值，所以才有了单值类型 Unit。它没有任何值）[1]

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

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

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

条件类 （Case Classes）

Scala 有一种特殊的类叫条件类。一般来说，条件类是不可变的，通过值进行比较。你可以使用关键字 case class 来定义条件类。

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

你可以不用 new 关键字就实例化条件类。

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.

这里有更多有关条件类的东西我想说，而且我相信你将会喜欢上它们。我们将会在之后深入讨论它。

对象 （Objects）

对象的定义是只有一个实例，你可以认为它们是单例类。

你可以使用关键字 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）

在特征中可以包括属性和方法，也可以包含多个特征。

你可以使用关键字 trait 来定义一个特征

trait Greeter {
    def greet(name: String): Unit
}

特征也可以有一个默认的实现。

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

你可以使用关键字 extends 来继承特征并且使用关键字 override 来实现特征中的方法

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 CustomizableGreeter("How are you, ", "?")
customGreeter.greet("Scala developer") // How are you, Scala developer?

这里， DefaultGreeter 只继承了一个特征，其实，它可以继承多个特征。

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

主方法 （Main Method）

主方法是编程的入口。Java 虚拟机需要一个名字为 main 和拥有一个参数，参数类型为字符串数组的主方法。

使用对象，你可以像下面一样定义一个主方法：

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

下一篇：Scala 之旅（TOUR OF SCALA）——统一类型（UNIFIED TYPES）