Scala的For、Function、Lazy、Exception

for循环，不论在哪个语言里面都是很基本的循环语句

for(i <- 1 to 2; j <- 1 to 2) print((100 * i + j) + "  ")

遍历集合：

val files = (new java.io.File(".")).listFiles()
for(file <- files){
    println(file)
}

条件守卫：

for(i <- 1 to 2; j <- 1 to 2 if i != j) print((100 * i + j) + "  ")

函数的定义：

def  addA(x : Int) = x +100
def looper(x : Long, y : Long) : Long = {
    var a = x
    var b = y
    while(a != 0){
      val temp = a
      a = b % a
      b = temp
    }
    b //函数结果不需要return关键字
  }  

一般情况下，是不需要声明返回值类型的，Scala很强大，能根据值进行类型推导。但是有个地方是特例，递归函数，必须指定返回值类型。
如果返回值为空，则使用Unit，如main：

def main(args: Array[String]): Unit = {}

或者干脆省略掉：

def main(args: Array[String]){}

如果连参数都没有，括号也可以省掉：

def current = age

匿名函数：

val  add = (x : Int) => x +200

递归函数：

def fac(n:Int):Int = if (n <= 0) 1 else n * fac(n - 1)//必须指定函数返回类型

参数默认值：

def combine(content:String, left: String = "[", right: String = "]") = left + content +right//函数参数可以指定默认值

可变参数

def connected(args: Int*) = {
      var result =0
      for(arg <- args) result += arg
       result //函数结果不需要return关键字
}
println("The result from a connected is : " + connected(1,2,3,4,5,6))

需要注意的是，由于在Scala中，object里所有内容都是静态的，所以，如果代码逻辑没有封装成函数，还是会执行的。封装成函数后，不调用就不会执行。

Lazy延迟加载，只有第一次使用时才会初始化

lazy val file = Source.fromFile("E:\\scalain.txt")
for (line <- file.getLines) println(line)

假定文件不存在，如果不加lazy，在第一句就会报错；而加上lazy关键字之后，只有第一次使用的时候（file.getLines）才会报错

异常处理：

    val n = 99
    try {
        val half = if (n % 2 == 0) n /2 else throw 
            new RuntimeException("N must be event")
    }catch {
      case e : Exception => println("The exception is :" + e.getMessage()) //通过case匹配异常，只匹配一个。
    }finally{}