一、数据类型
Scala和Java一样，有7种数值类型：Byte、Char、Short、Int、Long、Float、Double和无包装类型Boolean、Uint类型。
注意：Uint表示无值，和其他语言中的void等同。用作不返回任何结果的方法的结果类型。Uint只有一个实例值，写成（）
1.1 变量的定义
定义变量用var或者val关键字。
语法：
var 变量名称(:数据类型) = 变量值
val 变量名称(:数据类型) = 变量值
使用val修饰的变量，值不能被修改，相当于Java中的final修饰的变量。
定义变量时，可以指定数据类型，也可以不指定，不指定时编译器会自动推测变量的数据类型。
1 val name = "scala"
2 var age = 18
3 var nickname:String = "sl"
1.2 字符串的格式化输出
普通输出：
文字‘f’插值器允许创建一个格式化的字符串，类似于C语言中的printf。
在使用‘f’插值器时，所有变量引用都应该是printf样式格式说明符，如%d，%i，%f等。
‘s’允许在处理字符串时直接使用变量。
在println语句中将String变量（$name）附加到普通字符串中。
字符串插入器还可以处理任意表达式。
使用‘s’字符串插入器处理具有任意表达式（${1 + 1}）的字符串（1+1）的一下代码。任何表达式都可以嵌入到${}中。
1.3 条件表达式
1 val faceValue = 99
2 val res1 = if(faceValue > 90) "Good,it is." else "No, you are error!"
3 res1: String = Good,it is.
4
5 val i = 8
6 val res2 = if(i > 8) i
7 res2: AnyVal = ()
8
9 val res3 = if(i > 8) i else "here are string, what is res3?"
10 res3: Any = here are string, what is res3?
11
12 val score = 76
13 scala> val res4 = {
14 | if(score > 60 && score < 70) "ok"
15 | else if(score >= 70 && score < 80) "good"
16 | else "exerllent"}
17 res4: String = good
1.4 循环语句/yeild关键字
在scala中有for循环和while循环，用for训话比较多。
for训话语法结构：for(i <- 表达式/数组/集合)
1 // 定义个数组，元素为1到6
2 val array = Array(1, 2, 3, 4, 5, 6)
3 array: Array[Int] = Array(1, 2, 3, 4, 5, 6)
4
5 // 遍历打印数组中的每一个元素
6 for(ele <- array){ // 类似Java中的增强for循环
7 | println(ele)}
8 1
9 2
10 3
11 4
12 5
13 6
14
15 // 通过角标获取数组中的元素
16 // 定义一个0到5的角标范围
17 for(i <- 0 to 5){ // 0 to 5 =>会生成一个范围集合range(0, 1, 2, 3, 4, 5)
18 | println(array(i))}
19 1
20 2
21 3
22 4
23 5
24 6
25
26 for(i <- 0 until 6){ // 0 until 6 =>会生成一个范围集合range(0, 1, 2, 3, 4, 5)
27 | println(array(i))}
28 1
29 2
30 3
31 4
32 5
33 6
34
35 // to 和 until的区别就是to包含前后否为闭区间，until为前闭后开区间
36
37 // 打印数组中的偶数
38 for(e <- array if e % 2 ==0){ // for表达式中可以增加守卫
39 | println(e)}
40 2
41 4
42 6
43
44 scala> for(i <-1 to 3; j <- 1 to 3 if i != j){
45 | println((10 * i + j) + " ")}
46 12
47 13
48 21
49 23
50 31
51 32
1.5 运算符与运算符重载
Scala中的+、-、*、/、%等操作符合Java一样，未操作符&、|、^、>>、<<也一样。只是有一点特别的：这些操作符实际上是方法。
例如：
a+b
是用如下方法调用的简写：
a.+(b)
a 方法 b 可以写成 a. 方法 (b)
2 方法的定义与调用
方法的返回值类型可以不写，编译器可以自动推断出来，但是对于递归函数，必须制定返回值类型。
定义方法的格式为：
def methodName([list of parameters]) : [return type] = {}
如果不适用等号和方法体，则隐式声明抽象(abstract)方法。
1 def sum(a:Int, b:Int): Int = { 2 | a + b} 3 sum: (a: Int, b: Int)Int 4 5 val result = sum(1, 5) 6 println(result) 7 6 8 9 // 该方法没有任何参数，也没有返回值 10 def sayHello1 = println("Say BB1") 11 sayHello1: Unit 12 def sayHello2() = println("Say BB2") 13 sayHello2: ()Unit 14 15 sayHello1 // 如果方法没有()，则调用时也不能加() 16 Say BB1 17 18 sayHello2 // 如果方法有()，则调用时可以加()，也可以省略不加 19 Say BB2
方法可以转换为函数：（注意方法名和下划线“_”之间有空格）
3 函数的定义与调用
3.1 函数定义
函数定义方式一：
调用：f1(2)，其中f1为函数的引用，也可以叫做函数名。function1表述一个参数的函数。
函数定义方式二：
下面为没有任何参数的函数：
3.2 传值调用与传名调用
通常，函数的参数是传值参数；也就是说，参数的值在传递给函数之前确定。
其实，在Scala中，我们方法或者函数的参数可以是一个表达式，也就是将一个代码逻辑传递给了某个方法或者函数。
1 def currentTime(): Long = {
2 | println("Print this system time. uint: ns")
3 | System.nanoTime()
4 | }
5 currentTime: ()Long
6
7 // 该方法的参数为一个无参的函数，并且函数的返回值为Long
8 def delayed(f: => Long): Unit = {
9 | println("delayed ==========")
10 | println("time = " + f)}
11 delayed: (f: => Long)Unit
12
13 def delayed1(time: Long) = {
14 | println("delayed1==========")
15 | println("time1 = " + time)}
16 delayed1: (time: Long)Unit
17
18 delayed(currentTime)
19 delayed ==========
20 Print this system time. uint: ns
21 time = 6375384245048
22
23 val time = currentTime()
24 Print this system time. uint: ns
25 time: Long = 6405083232147
26
27 delayed1(time)
28 delayed1==========
29 time1 = 6405083232147
3.3 可变参函数
1 def methodManyParams(a: String*) = {
2 | for(p <- a){
3 | println(p)}}
4 methodManyParams: (a: String*)Unit
5
6 methodManyParams("People's", "Republic of", "China")
7 People's
8 Republic of
9 China
3.4 默认参数函数
3.5 高阶函数
3.6 部分参数应用函数
如果函数传递所有预期的参数，则表示已经完全应用它。如果只传递几个参数并不是全部参数，那么将返回部分应用的函数。这样就可以方便的绑定一些参数，其余的参数可以稍后填写补上。
上述，log()方法有两个参数，date和message。我们想要多次调用该方法，具有相同的日期值，但不同的消息值。可以通过将参数部分的应用到log()方法来消除将日期传递给每一个调用的干扰。为此，首先将值绑定到date参数，并将第二个参数绑定到其位置。结果是存储变量中的部分应用函数。
3.7 柯里化（Currying）
柯里化指的是将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数的为参数的函数。
3.8 偏函数
被包在花括号内没有match的一组case语句是一个偏函数，它是PartialFunction[A,B]的一个实例，A代表参数类型，B代表返回类型，常用作输入模式匹配。
3.9 数组的定义
3.10 map、flatten、flatMap、foreach方法的使用
