Scala基本语法学习

对于Scala的介绍引用《Scala in Action》中的描述：

Scala is a general-purpose programming language designed to express common pro-gramming patterns in a concise, elegant, and type-safe way. It smoothly integrates fea-tures of object-oriented and functional programming languages, enabling programmers to be more productive.

Scala是一种多范式的语言，结合了面向对象和函数式编程语言的特点。Scala是一门一接触就会让你爱不释手的语言。正如《Scala in Action》中所描述的，它是一门简洁，优雅的语言，能够激发程序员的创造力。

一 基本类型

(1) 整型类型

Scala的基本类型包括：Byte，Short，Int，Long，Float，Double，Boolean，Char。其中Byte，Short，Int，Long，Char为整型类型。

• 数字会被解析为十进制整数
• Long型整数需要在数字后加L或l表示
• 十六进制加0x前缀
• 八进制加0作为前缀已经被废弃

scala> val decimalInt = 23456decimalInt: Int = 23456scala> val longInt = 23456LlongInt: Long = 23456scala> val hexInt = 0x23456hexInt: Int = 144470scala> val octalInt = 023456<console>:1: error: Decimal integer literals may not have a leading zero. (Octal syntax is obsolete.)val octalInt = 023456               ^scala> val byteVal : Byte = 1byteVal: Byte = 1

（2）布尔型

scala> val boolenVal = falseboolenVal: Boolean = falsescala> val booleanVal = truebooleanVal: Boolean = truescala> val booleanVal = "false"booleanVal: String = false

（3） 浮点型

Scala的浮点数类型包括Float和Double，浮点数由整数，小数点，小数部分构成.

scala> val doubleval = 0.0doubleval: Double = 0.0scala> val floatVal = 0.0ffloatVal: Float = 0.0scala> val floatVal = 0ffloatVal: Float = 0.0

从交互式命令结果可以看出0.0默认为Double类型，如果要定义一个Float类型的数值可以加上f作为后缀。在数值基本类型中，Scala的默认类型转换方式为：Byte->Short->Int->Long->Float->Double。

（4） 字符型Char

字符由单引号定义，可以转换为Int（Char->Int）

scala> val charVal = 'a'charVal: Char = ascala> val char2Int : Int = charValchar2Int: Int = 97

(5)  字符串类型String

字符串由双引号定义，如果在字符串中存在双引号则需要用反斜杠(\)转义。在Scala中，字符串类型String为java.lang.String类型。

scala> val stringVal = "hello scala"stringVal: String = hello scala

二  定义变量

在Scala中有两种类型的变量“val”和“var”，val（single assignment value）相当于Java中的final变量（不可变的变量），一次赋值无法修改。var则为一般的变量类型，可以重新复制（可变变量）。Scala认为可变变量会引起副作用（Side Effect），建议使用val声明不可变变量，在不得已的情况下才使用var声明可变变量。

scala> val val1 = 10val1: Int = 10scala> val1 = 20<console>:12: error: reassignment to val       val1 = 20            ^scala> var val2 = 10val2: Int = 10scala> val2 = 20val2: Int = 20

变量类型可以通过在变量名后加冒号（：）指定变量类型。在很多情况下Scala的类型推导可以得到变量的正确类型而不用明确指定。如下所示：

scala> var inferenceVar = 1inferenceVar: Int = 1scala> var intVar : Int = 1intVar: Int = 1scala> var intVar : Float = 1intVar: Float = 1.0

Scala针对val变量也有一个延迟初始化的机制。lazy（惰性变量修饰符）修饰val变量（只有val变量才能声明为lazy），表示在第一次使用到该val变量时才会初始化它，而不是在声明时，如：

scala> var a = 1a: Int = 1scala> var b = 2b: Int = 2scala> lazy val c = a + b + 1c: Int = <lazy>scala> a = 2a: Int = 2scala> b = 3b: Int = 3scala> cres0: Int = 6

从上面的执行结果可以看出变量c在声明为lazy后并没有立即赋值，否则c的值应为4而不是6.lazy延迟初始化会在变量第一次使用时才真正执行初始化。lazy变量适用的场景是变量在处理逻辑中可能不会被使用，尤其是变量求值计算比较复杂的情况下。

三 函数定义

scala函数完整定义如下：

def myMethod(param1 : String, param2 : String) : String = {“这里是函数的处理逻辑。。。”}

• scala中函数以def开头进行定义
• 定义函数以此为def关键字，函数名，函数参数（由括号括起来），冒号，返回值类型，等号，函数体（由大括号括起来）

scala> def sayHello(name: String) : String = {"Hello " + name}sayHello: (name: String)Stringscala> var result = sayHello("Scala")result: String = Hello Scalascala> println(result)Hello Scala

完整的scala函数定义由上述的7部分（包含冒号，等号）组成，但在实际应用中这7部分并不是都必须存在。

(1) 没有参数

scala> def sayHello() : String = {"Hello world"}sayHello: ()Stringscala> println(sayHello())Hello world

(2) 没有返回类型。借助Scala强大的类型推导机制，可以省略函数的返回类型。根据类型推导可以得出函数sayHello的返回类型为String。

scala> def sayHello() = {"Hello world"}sayHello: ()String

(3)没有等号。在函数定义中，等号不仅仅只是为了区分函数签名和函数体，而且等号的存在表示要求Scala利用类型推导机制推导返回类型。如果去掉等号，则Scala不会进行返回类型的推到，返回类型为Unit（等同于Java中的void）

scala> def sayHello() {"Hello world"}<console>:11: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses       def sayHello() {"Hello world"}                       ^sayHello: ()Unit

从REPL返回的结果中可以看出方法等返回类型为Unit

(4)省略方法体等大括号

scala> def getGreetingString() = "Hello Scala"getGreetingString: ()String

(5)省略参数中括号，因为没有参数，所以Scala允许忽略掉。这种写法感觉很像是定义变量，但def关键字表明这是一个函数

scala> def getGreetingString = "Hello Scala"getGreetingString: Stringscala> println(getGreetingString)Hello Scala