day03-scala学习之函数参数、Lazy(懒值)、异常处理

前言

day02(day02-scala学习之条件表达式及循环)，我们学习了scala的条件表达式及循环，今天学习scala函数参数、Lzay(懒值)、异常处理。

scala函数参数

参数类型

scala的参数分为默认参数、带名参数、可变参数三种。
默认参数，当你没有给参数赋值的时候，就使用默认参数

object Demo5 {
  def test1(name:String="Tom"):String = "Hello " + name
   }
  def main(args: Array[String]): Unit = {
    val a = test1()
    val b = test1("sjr")
    println(a)
    println(b)
    }
}

代名参数，当有多个默认参数的时候，通过代名参数可以确定给哪个参数赋值

object Demo5 {
  def test2(str:String="Goog Morning,",name:String="Tom",age:Int=20)=str + name + "and the age of " + age
  def main(args: Array[String]): Unit = {
    val c = test2(age=18)
    println(c)

可变参数，类似于java中的可变参数，即，参数数量不固定。

object Demo5 {
  def sum(args:Int*) = {
    var result = 0
    for(x <- args) result += x
    result
  }
  def main(args: Array[String]): Unit = {
    val d = sum(2,3,5,7)
    println(d)
  }
}

参数求值策略

scala的参数有两种求值(调用)策略，如下：

1. call by value：对函数实参求值，且仅求一次，定义方式如下：
   参数名 : 数据类型 如 x: Int
2. call by name：函数实参每次在函数体内被用都会求值，定义方式如下：
   参数名 : => 数据类型 如 x: =>Int

下面写一个Demo来具体分析两种参数的区别

object Demo4 {
  //定义一个死循环
  def loop() : Int = loop
  //定义test函数，x是call by value,y是call by name
  def test(x : Int,y : => Int) = 1
  def main(args: Array[String]): Unit = {
    /**
      * 把死循环的函数传到call by name的参数中，
      * 因为call by name的参数是只求值一次，所以存在死循环的函数只执行一次就出来了
      */
    test(5,loop)
    println("test(5,loop) 执行成功")
    /**
      * 把死循环的函数传到call by value的参数中,
      * 因为call by value 的参数是每次调用都进行求值，所以会进入死循环不出来
      */
    test(loop,5)
    println("test(5,loop) 执行成功")
  }
}

上面的代码的运行结果截图如下：

控制如只输出"test(5,loop) 执行成功"，而后进入到“test(5,loop)”，这个语句是把死循环的函数作为参数传到了call by value的参数中，每次调用都会对参数进行求值，所以进入死循环一直出不来。表示为IDE在输出"test(5,loop) 执行成功"后就卡住。

scala的Lazy(懒值)

Spark的核心是RDD(数据集合)，操作数据集合中的数据时，我们使用算子(函数、方法)，算子分为两种：

1. Transformation：延时计算的，不会立刻进行计算。Transformation类型的算子底层其实就是使用了scala的Lazy懒值。
2. Action：触发计算的。
   Lazy的定义方式：lazy val 常量名 = 具体的值
   如下是在scala命令行下进行的一些操作的情况。
   

异常处理

Scala异常的工作机制和Java或者C++一样。直接使用throw关键字抛出异常或使用try…catch捕获异常进行处理。

Scala 抛出异常的方法和 Java一样，使用 throw 方法。

如下是一个使用try…catch捕获异常进行处理的Demo，与java不同的是，它的catch后是通过case来对应异常进行处理的，有点像模式匹配中case的格式。另外，如果有需要不管如何都要执行的语句，可以使用finally

import java.io.{FileNotFoundException, PrintWriter}
import scala.io.Source.fromFile
/**
  * 从win读取文件student.txt然后写进student1.txt文件中
  */
object Demo{
  def main(args: Array[String]): Unit = {
    try{
      val word = fromFile("C:\\javacore\\student.txt")
      val lines = word.getLines()
      val write = new PrintWriter("C:\\javacore\\student1.txt")
      lines.foreach(write.println)
      word.close()
      write.close()
    }catch {
      case e : FileNotFoundException => {
        println("文件不存在")
      }
      case e : Exception => {
        println("进程异常退出")
      }
    }finally {
      println("进程执行完成")
    }
  }
}