scala基础语法
声明值和变量
scala使用val或者var声明变量
var/val 变量名[:变量类型]=变量值
val定义的变量，值是不可变的，是一个常量
var a=10
var b="hello"
val author="upuptop"
变量类型可以省略，解析器会根据值判断，val和var声明变量时都必须初始化。尽可能的使用不可变变量
常用类型
- Boolean：true或者false
- Byte：8位 有符号
- Short：16位 有符号
- Int：32位 有符号
- Long：64位 有符号
- Char：16位 无符号
- Float：32位，单精度浮点数
- Double：64位 双精度浮点数
与java不同，scala不区分引用类型和基本类型，所以这些类型都是对象，可以调用相应的方法。
Scala没有强制类型转换，需要通过方法进行类型的转化
scala中所有的值都是类对象，所有的类，包括值类型，都最终继承自根类型：Any。
特殊：
Null是所有引用类型的子类型，只有一个实例对象，null类似于java中null的引用。Nothing可以作为没有正常返回值的方法的返回类型。是所有类型的子类型Unit类型用来标识过程，也就是没有明确返回值的函数。类似于java中的void。只有一个实例对象()这个实例没有实质意义
操作符
+ - * / %可以完成和java相同的工作。但是他们都是方法。
下面代码，第二个操作就相当于1调用了+()方法并传递了2为参数
scala> 1+2
res0: Int = 3
scala> 1.+(2)
res1: Int = 3
Scala中没有++ --操作符，需要通过+= -=实现
调用函数和方法
除了方法，Scala还提供了函数，比如数学函数：
调用函数 导入包
import 包名._
注：_ 在这里是通配符相当于java中的*
scala> import scala.math._
import scala.math._
scala> sqrt(3)
res2: Double = 1.7320508075688772
调用静态方法
Scala中没有静态方法，一般通过到单例对象或者伴生对象进行实现
scala> BigInt.probablePrime(100,scala.util.Random)
res3: scala.math.BigInt = 719354201634616441856306472377
调用对象的方法
String的去重方法：
scala> "upuptop".distinct
res4: String = upto
apply与update方法
apply方法调用时可以省略方法名。用于构造和获取元素
scala> var a = "hello".apply(4)
a: Char = o
scala> var c = "hello"(4)
c: Char = o
update方法调用时可以省略方法名。用于元素的更新
scala> var arr = Array(1,2,3,4)
arr: Array[Int] = Array(1, 2, 3, 4)
scala> arr.update(0,5)
scala> arr
res10: Array[Int] = Array(5, 2, 3, 4)
scala> arr(0)=0
scala> arr
res12: Array[Int] = Array(0, 2, 3, 4)
控制结构和函数
java中把表达式和语句当成两个不同的东西，表达式有值，语句没有值，只是控制结构，在Scala中几乎所有的语法结构都有值。
if……else表达式
scala> var x = 10
x: Int = 10
scala> var s = if(x>9) 1 else -1
s: Int = 1
没有三元运算，不需要
if表达式的返回值类型取决于最后一条语句，如果if和else的返回值类型不一致那么就返回Any类型。
行尾不需要写分号，只要能够从上下文判断出语句的终止即可。但是如果在单行中写多个语句，需要使用分号分割。
while表达式
Scala提供和java一样的while和do循环。while语句没有返回值
scala> while(i<=100){
sum+=i
i+=1
println(sum)
}
scala> do{
i+=1
sum+=i
}while(i<100)
Scala没有提供break和continue语句来退出循环，如果需要break，可以通过下面方法进行实现
- 使用Boolean类型的控制变量
- 使用嵌套函数，从函数中return
- 使用Breaks对象中的break方法。
for表达式
scala> for(i<- 1 to 100; if i <= 100){
sum+=i
}
scala> sum
res31: Int = 5050
i<- 1 to 100:i从1 到100
变量名 <- 集合这样的表达式也被称为生成器表达式，该表达式会基于集合生成单独的数值
if i <= 100成为保护式（守卫）可以由一个或者多个
for推导式可以引入变量
scala> for(i<- 1 to 3;fff = 4 - i )print(fff+" ")
3 2 1
for循环的返回值
yield关键字
scala> var resuu = for(i<- 1 to 3;fff = 4 - i ) yield fff
resuu: scala.collection.immutable.IndexedSeq[Int] = Vector(3, 2, 1)
{}和()for 后面使用{}表达式之间可以不使用分号，换行，使用()必须使用分号进行分割
scala> for{
i <- 1 to 3
from = 4 - i
j <- from to 3
}
print((10*i+j)+" ")
13 22 23 31 32 33
函数
定义
def 函数名（参数名：类型...）[:返回值类型] = 函数体
def 函数名（参数名：类型...）[:返回值类型] {
函数体
}
递归函数：求阶乘，递归函数必须有返回值
def recursiveFuc(x: Int): Int = if (x == 0 || x == 1) 1 else x * recursiveFuc(x - 1)
println(recursiveFuc(5))
参数默认值函数：
def sum(a: Int = 1, b: Int) = a + b
println(sum(b = 1))
变长函数/可变参数
def sum(a: Int*): Int = {
var res = 0
for (i <- a) res += i
// 相当于 return res
res
}
println(sum(1,2,3,4,5))
过程
不返回值得函数叫做过程，返回类型是Unit，没有等号
def noRet(name: String): Unit = {
println(s"hello ${name}")
println("hello" + name)
}
noRet("upuptop")
懒值
当val被声明为lazy时，它的初始化将被推迟，知道我们开始使用的时候才会取值。
- 用于初始化开销比较大的语句
- 可以解决循环依赖问题
- 是开发懒数据结构的基础
lazy val a = 100
异常
抛出异常
抛异常使用throw关键字，不需要在方法或者函数上声明异常
所有的异常都是Throwable的子类型。throw表达式也是有类型的，是nothing
def fun(a: Int, b: Int): Int =
if (b == 0) {
throw new Exception("/ by zore")
} else {
a / b
}
try {
println(fun(1, 0))
} catch {
case e: Exception => println(s"出现异常${e}")
} finally {
println("finally")
}
打印结果：
出现异常java.lang.Exception: / by zore
finally
res0: Unit = ()