Scala基本语法入门

一、数据类型

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