Scala基础语法

if表达式的定义：在Scala中，if表达式是有值的，就是if或者else表达式中最后一行语句的返回值。

object IfDemo {
    def main(args: Array[String]): Unit = {
        val age = 28
        val isAdult = if (age > 25) 1 else 0
        println(isAdult)
    }
}

if表达式的类型推断：由于if表达式是有值的，Scala会自动对返回值的类型进行推断，取if和else表达式的值类型的公共父类型。比如if表达式的值类型是Int，else表达式的值类型是Unit，也用()表示，则表达式的值类型是Any。这里，Any是Int和Unit的公共类型。

while do循环：Scala有while do循环，基本语义与Java相同。

object Demo {
    def main(args: Array[String]): Unit = {
        var n = 20 // 定义变量
        while(n > 0) {
            println(n)
            n -= 1
        }
    }
}

Scala没有for循环，只能使用while替代for循环，或者使用简易版的for语句

简易版的for语句：

object Demo {
    def main(args: Array[String]): Unit = {
        val n = 20 // 定义变量
        for (i <- 1 to n) {
            println(i)
        }
    }
}

Scala跳出循环语句：Scala没有提供类似于java的break语句，但是可以使用boolean变量、return或Breaks的break函数来替代使用。

import scala.util.control.Breaks._

object Demo {
    def main(args: Array[String]): Unit = {
        breakable {
            var n = 10
            for(c <- "Hello World") {
                if(n == 5) {
                    break
                }
                print(c)
                n -= 1
            }
        }
    }
}

Scala之九九乘法表：

object Demo {
    def main(args: Array[String]): Unit = {
        for (i <- 1 to 9; j <- 1 to i) {
            print(i + "*" + j + "=" + (i * j) + "	")
            if (i == j) {
                println()
            }
        }
    }
}

if守卫：取偶数

object Demo {
    def main(args: Array[String]): Unit = {
        for (i <- 1 to 20 if i % 2 == 0) {
            println(i + "是偶数.")
        }
    }
}

for推导式：构造集合

object Demo {
    def main(args: Array[String]): Unit = {
        val newValue: Seq[Int] = for (i <- 1 to 10) yield {
            i * 2
        }
        println(newValue)
    }
}

Scala函数：在Scala中定义函数时，需要定义函数的函数名、参数、函数体。Scala要求必须给出所有参数的类型，但是不一定给出函数返回值的类型，只要右侧的函数体中不包含递归的语句，Scala就可以自己根据右侧的表达式推断出返回类型。

函数定义：def 函数名(参数1:参数类型1,参数2:参数类型2...)[:返回值类型]={函数体}

举例：

def sum(n: Int) = {
  var sum = 0for(i <- 1 to n) sum += i
  sum
}

递归函数与返回类型：如果在函数体内递归调用函数自身则必须手动给出函数的返回类型。

举例：实现经典的斐波那契数列

1, 1, 2, 3, 5, 8, 13, ...

def fab(n: Int): Int = {
    if(n <= 1) 1
    else fab(n - 1) + fab(n - 2)
}

Scala之默认参数：在Scala中，有时我们调用某些函数时，不希望给出参数的具体值，而希望使用参数自身默认的值，此时就可以在定义函数时使用默认参数。

def sayHello(firstName: String, middleName: String = "Jackson", lastName: String = "Jhon"): String = firstName + " " + middleName + " " + lastName

Scala之变长参数：在Scala中，有时我们需要将函数定义为参数个数可变的形式，则此时可以使用变长参数定义函数。

举例：

def sum(nums: Int*): Int = {
    var res = 0
    for (num <- nums) {
        res += num
    }
    res
}

使用序列调用变长参数：在如果想要将一个已有的序列直接调用变长参数函数，是不对的。比如val res = sum(1 until 10)。此时需要使用Scala的特殊语法将参数定义为序列让Scala解释器能够识别。

举例：使用递归函数实现累加

object Demo {
    def main(args: Array[String]): Unit = {
        println(sum(1 to 10: _*))
    }

    def  sum(nums: Int*): Int = {
        if (nums.length == 0) {
            0
        } else {
            nums.head + sum(nums.tail: _*)
        }
    }
}

 Scala中的lazy值：在Scala中，提供了lazy值的特性，也就是说，如果将一个变量声明为lazy，则只有在第一次使用该变量时，变量对应的表达式才会发生计算。这种特性对于特别耗时的计算操作特别有用，比如打开文件进行IO，进行网络IO等。

import scala.io.Source._
lazy val lines = fromFile("C://Users//Administrator//Desktop//test.txt").mkString
即使文件不存在，也不会报错，只有第一个使用变量时会报错，证明了表达式计算的lazy特性。

val lines = fromFile("C://Users//Administrator//Desktop//test.txt").mkString
lazy val lines = fromFile("C://Users//Administrator//Desktop//test.txt").mkString
def lines = fromFile("C://Users//Administrator//Desktop//test.txt").mkString

Scala中的异常处理：在Scala中，异常处理和捕获机制与Java是非常相似的。

import java.io.IOException

object Demo {
    def main(args: Array[String]): Unit = {
        try {
            throw new IllegalArgumentException("x should not be negative")
        } catch {
            case _: IllegalArgumentException => println("Illegal Argument!")
        } finally {
            println("release resources!")
        }

        try {
            throw new IOException("user defined exception")
        } catch {
            case e1: IllegalArgumentException => println("illegal argument")
            case e2: IOException => println("io exception")
        }

    }
}