Scala编程基础2：函数、递归、异常

一、函数的定义与调用

/**
 * 函数：在object内部编写
 * 方法（成员方法）：在class内部编写
 */

object FunDemo1 {
  def main(args: Array[String]): Unit = {
    /**
     * def:定义函数或者方法的关键字
     * main：函数名 main函数是被jvm(java虚拟机)所特有识别的程序入口
     * args:参数名
     * Array[String]:参数的数据类型
     * Unit:返回值类型 相当于java中的void
     *
     * scala：def main(args: Array[String]): Unit = {}
     * 等价于
     * java：public static void main(String[] args)
     */
    
    /**
     * 函数的调用：
     * 1、在object对象内部，函数相当于加了一个static,可以直接使用object对象名调用
     * 2、在同一作用域下（同一个大括号下），调用时可以不加对象名
     * 3、函数可以在object对象中任意一个地方调用
     *
     */

    //函数的调用也可以简写
    //1、如果调用的函数只有一个参数的时候,可以按照下列方式简写
    val strings: String = "java.scala.spark,flink"
    val arr1: Array[String] = strings split '.'
    println(arr1(1))

    //调用所有add函数
    println(add0(11, 22.2)) //println(FunDemo1.add0(11, 22.4))
    println(add1(11, 22.2))
    println(add2("11", "22"))
    println(add3(11))
    //如果函数没有参数，调用时可以省略函数名后面的括号
    add4
    println(add5(11,"R"))


    //scala可以在方法内定义函数，java不可以
    def add5(a: Int, b: String): String = a.toString + b


  }

  /**
   * 定义函数时的简写方案：
   * 1、如果函数体中最后一行语句作为返回值的时候，return可以省略不写
   * 2、如果函数体中只有一行语句实现，{}可以省略不写
   * 3、函数的返回值可以进行自动类型推断，可以省略不写，但是对于递归函数，必须指定返回类型
   * 4、如果函数没有参数列表的话，（）可以省略不写
   *
   */

  //原始写法
  def add0(a: Int, b: Double): Double = {
    return a + b
  }

  //1、如果函数体中最后一行语句作为返回值的时候，return可以省略不写
  def add1(a: Int, b: Double): Double = {
    a + b
  }

  //2、如果函数体中只有一行语句实现，{}可以省略不写
  def add2(a: String, b: String): Int = a.toInt + b.toInt

  //3、函数的返回值可以进行自动类型推断，可以省略不写
  def add3(a: Int) = a.toString + "#"

  //4、如果函数没有参数列表的话，（）可以省略不写
  def add4 = println("好好学习，天天向上")

}

二、递归

函数的递归：函数内部调用函数本身的现象，叫做递归

object FunDemo2 {
  def main(args: Array[String]): Unit = {
    //求5的阶乘
    println(jiecheng(5))
    
    def jiecheng(number: Int): Int = {
      var numSum: Int = 1
      if (number == 1) {
        numSum
      } else {
        numSum * jiecheng(number - 1)
      }
    }
  }
}

三、异常

scala是对java语言的封装，scala中异常事实上就是java中的异常类

1、Error

2、Exception

      --编译时期异常

      --运行时期异常  RuntimeRxception

import java.io.{BufferedReader, FileNotFoundException, FileReader}

object FunDemo3 {
  def main(args: Array[String]): Unit = {
    /**
     * scala默认处理异常的方式是向外抛，如果程序报错，后续代码不会运行
     *
     * scala处理异常的另一种方式和java一样，try...catch..final,但是语法有些许区别
     */

    try {
      val br = new BufferedReader(new FileReader("xxx/xxx/xx/xx"))
//      val arr1: Array[Int] = Array[Int](11, 22, 33, 44)
//      println(arr1(4))
    } catch {
      //模式匹配,捕获并处理对应的异常，如果不知道异常种类，可直接使用Exception处理
//      case e: FileNotFoundException => println("文件路径找不到异常")
//      case e: ArrayIndexOutOfBoundsException => println("数组索引越界异常")
      case e:Exception=>println("有异常")
    }finally {
      //无论有没有对应的case捕获，都会执行
      println("finally")
    }

  }
}

注意：

1、scala默认处理异常的方式是向外抛，如果程序报错，后续代码不会运行

2、scala处理异常的另一种方式和java一样，try...catch..final,但是语法有些许区别