一、前言

Scala语言是一个完全面向对象编程语言。万物皆对象；

对象的本质：对数据和行为的一个封装 。

Scala语言是一个完全函数式编程语言。万物皆函数。 解决问题时，将问题分解成一个一个的步骤，将每个步骤进行封装（函数），通过调用这些封装好的步骤，解决问题；

函数的本质：函数可以当做一个值进行传递 。

在Scala中函数式编程和面向对象编程完美的结合在了一起。

二、函数基础

2.1 基础概念

1. 函数：为了完成某一功能的程序语句的集合称为函数；
2. 方法：类中的函数称为方法；
3. 函数没有重写、重载的概念；方法可以重写、重载；
4. Scala语言可以在任何语法结构中声明任何的语法；
5. Scala可以在函数中嵌套定义；
6. 示例代码：

   object FunctionTest {
     def main(): Unit = {}
   
     //方法重载
     def main(args: Array[String]): Unit = {
       println("这是main方法的重载方法")
   
       //Scala可以在任何的语法结构中声明任何的语法
       import java.util.Date
       println(new Date())
   
       //定义函数
       def test(): Unit = {
         println("无参无返回值test函数")
       }
       //调用test函数
       test()
       //程序报错，函数没有重写、重载的概念
       //      def test(name:String):Unit = {
       //        println("有参无返回值函数")
       //      }
   
   
       //函数中嵌套定义
       def test2(): Unit = {
         def test3(name: String): Unit = {
           println("这是在main方法中test2函数中嵌套定义的test3函数")
         }
         test3("zhangsan")
       }
       test2()
     }
   }
   
   输出：
   这是main方法的重载方法
   Fri Feb 11 18:52:22 CST 2022
   无参无返回值test函数
   这是在main方法中test2函数中嵌套定义的test3函数

2.2 函数的定义

1. 无参，无返回值；
2. 无参，有返回值；
3. 有参，无返回值；
4. 有参，有返回值；
5. 多参，无返回值；
6. 多参，有返回值；

2.3 函数的参数

1. 函数的参数可以是可变参数；
2. 如果参数列表中存在多个参数，可变参数一般放在参数列表的最后；
3. 如果参数有默认值，一般将有默认值的参数放在参数列表的后面；
4. 带名参数

   object FunctionTest02 {
     def main(args: Array[String]): Unit = {
       //定义带有可变参数的函数
       def test(s: String*): Unit ={
         println(s)
       }
       //输入参数：输出Array
       test("Hello","Scala")
   
       //无输入参数：输出结果为List（）
       test()
   
       //如果函数列表中存在多个参数，可变参数一般放在最后
       def test2(name:String,age:Int,s:String*): Unit ={
         println(name + "," + s)
       }
       test2("zhangsan",18,"hello")
   
       //带有默认值的参数
       def test3(name:String,age:Int = 20): Unit ={
         println(s"$name,$age")
       }
       //传参覆盖默认值
       test3("lisi",18)
       //不传参，使用默认值
       test3("wangwu")
   
       //带名参数，这样就不用按照参数列表的顺序输入参数了
       test3(age = 30,name = "xiaoming")
     }
   }
   
   输出：
   WrappedArray(Hello, Scala)
   List()
   zhangsan,WrappedArray(hello)
   lisi,18
   wangwu,20
   xiaoming,30

2.4 Scala中函数至简原则（重点）

1. return可以省略，Scala会使用函数体的最后一行代码作为返回值 ；
2. 如果函数体只有一行代码，可以省略花括号 ；
3. 返回值类型如果能够推断出来，那么可以省略；
4. 如果有return，则不能省略返回值类型，必须指定；
5. 如果函数明确声明unit，那么即使函数体中使用return关键字也不起作用；
6. Scala如果期望是无返回值类型，可以省略等号 ；
7. 如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加 ；
8. 如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略；
9. 如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略；

对应的代码示例：

  def main(args: Array[String]): Unit = {
    //1、省略return
    def f1(s: String): String = {
      s + ",Scala."
    }
    println(f1("Hello"))
    //2、如果函数只有一行，可以省略花括号
    def f2(s: String): String = s + ",HAHA"
    println( f2("hello"))
    //3、如果返回值可以推断出来，那么可以省略
    def f3(s: String) = s + "World."
    println(f3("省略返回类型的方法："))
    //4、如果有return，则必须指定返回类型
    def f4(s: String): String = return s
    println(f4("因为有return，必须执行返回类型"))
    //5、若返回类型式Unit，则有return也不起作用
    def f5(): Unit = return "zhangsan"
    println(f5())
    //6、如果Scala希望无返回值类型，则可以省略等号
    def f6(){ "lisi" }
    println(f6())
    //7、如果函数无参，但是有参数列表，那么调用时，小括号可加可不加
    def f7(): Unit ={
      "wangwu"
    }
    println(f7)
    //8、如果函数没有参数列表，那么调用时必须省略小括号
    def f8: Unit = "tadajiu"
//    f8()  程序错误
    println(f8)
    //9、如果只关心函数逻辑，不关心函数名，那么函数名(def)可以省略
    //"=>" 可以用来连接匿名函数
    var var1 = (s: Int) => s + 2

    //这里是"=>"的By-Name Parameters用法
    //函数f9中的参数fun 就是by-name，如果f9中传入普通的字符串或者非函数的变量，那么f9就和普通的函数用法完全一样
    //但是当把一个返回值为String类型的函数f10传入f9时，那么f10就会被先执行后再当作参数传入f9.
    def f9(fun: => String): Unit = {
      fun + "By-Name函数示例"
    }
    def f10():String = {
      "xionger"
    }
    println(f9(f10))
  }
}