3.1if else表达式
在Scala中，几乎所有语法结构都有值。
If语句的返回类型取决于最后一条语句。
Scala 没有三元运算符
If表达式会有一个返回值类型，如果if或者else返回的类型不一样，就返回Any(公共超类)
对于空值，使用Unit类，写做()【叫做无有用占位符，相当于java中的void】
如果在单行中写多个语句，则需要分号分割。
块包含一系列表达式，其结果也是一个表达式。块中最后一个表达式的值就是块的值。
3.2 while表达式
整个While 语句的结果是Unit类型的（）。
注：scala并没有提供break和continue语句来退出循环
如果需要break，可以通过几种方法来做
1、使用Boolean型的控制变量
2、使用嵌套函数，从函数中return
3、使用Breaks对象的break方法。
3.3for表达式
推导式一词起源于函数式编程。
像变量名<-集合这样的表达式也被称为生成器表达式
使用yield关键字便能在for表达式中生成新的集合。
3.4函数
Scala提供了很多函数，如math函数
注：
1、Scala通过=右边的表达式推断出函数的返回类型。如果函数体需多个表达式，用代码块{}。
2、可以把return当做函数版本的break 语句。
3、递归函数一定要指定返回类型。
4、变长参数通过来指定，所有参数会转化为一个seq序列
5、_告诉编译器Range当做参数序列化处理。
6、Head是获得首元素，tail是获取剩下元素的序列。
3.5过程
没有返回值的函数叫做过程，返回类型是Unit
3.6懒值
当val被声明为lazy时，他的初始化将被推迟，直到我们首次对此取值。
懒值使用注意：
1）用于初始化开销比较大的语句。
2）可以解决循环依赖问题。
3）是开发懒数据结构的基础。
3.7异常
Scala的异常的工作机制和Java一样，但是Scala没有“受检”异常
所有异常都是Throwable的子类型。
throw表达式是有类型的，就是Nothing。因为Nothing是所有类型的子类型，所以throw表达式可以用在需要类型的地方。
在Scala里，借用了模式匹配的思想来做异常的匹配，在catch的代码里，是一系列case字句。
import org.scalatest.FunSuite
class Chapter02Test extends FunSuite {
test("ch0201") {
//传统的if else 判断
var bol = if (1 + 1 == 2) true else false
//if else 可以有返回值
val x = if (bol) 1 else -1
println(bol)
//类型不一致时候 返回超类Any
val y = if (x > 0) "false" else -1
//没有返回值 返回Unit
val z = if (x > 0) 1
//一般不需要;分号
var a = 1
//多行代码写在一行 需要使用;分好 可以不使用大括号
if (a > 0) {
println(1);
println(2)
}
//{} 代码块的值就是最后一个表达式的值
if (a > 0) {
a -= 1
}
}
test("ch0202") {
//占位符
val name = "jim"
val age = 42.22
println(f"Hello, $name! You are $age%7.2f years old%n")
}
test("ch0203") {
//while循环结构 以及break跳出循环
import scala.util.control.Breaks._
var index = 10
while (index >= 0) {
index = index - 1
println(index)
if (index == 5) {
break
}
}
//do while循环结构
index = 10
do {
index = index - 1
println(index)
} while (index >= 0)
}
test("ch0204") {
//for循环 1到10
for (i <- 1 to 10) {
println(i)
}
//for循环 多个变量
for (i <- 1 to 9; j <- 1 to 9) {
println(i * j)
}
//for循环 条件表达式 守卫模式（支持多个条件表达式）
for (i <- 1 to 9; j <- 1 to 9; if i != j) {
println(i * j)
}
//for循环引入变量
for (i <- 1 to 3; from = 4 - i; j <- from to 3) print((10 * i + j) + " ")
//for循环推导式yield
var result = for (i <- 1 to 10) yield i
println(result)
}
//定义一个函数 函数的返回值可以自行推断
def abs(n: Int) = {
if (n < 0) {
-n
} else {
n
}
}
//定义一个递归函数必须指明类型
//这是一个阶乘
def fun(n: Int): Int =
if (n <= 0) 1 else n * fun(n - 1)
//没有返回值的函数 称为过程
def printNumber(n: Int): Unit = {
for (i <- 1 to 10) println(i)
}
// 变长参数
def sum(args: Int*) = {
var result = 0
for (arg <- args) result += arg
result
}
test("ch0205") {
println(abs(-1))
printNumber(10)
}
//定义一个初始化的方法
def init(): String = {
"init"
}
//没有延迟加载的函数
def noLazyFunction(): Unit = {
var str = init()
println(str)
}
//有延迟加载的函数
def lazyFunction() = {
lazy val str = init()
println(str)
}
test("ch0206") {
noLazyFunction()
lazyFunction()
}
//异常的处理
test("ch0207") {
import scala.math._
var index: Int = (-1)
//异常的抛出
if (index < 0) {
//throw new IllegalArgumentException("x must bigger than zero")
}
//异常的捕获
try {
sqrt(-1)
} catch {
case e: Exception => println(e)
} finally {
println("finally")
}
}
}
