scala学习-函数篇

函数式编程

函数基本语法

函数和方法的区别

1）核心概念
（1）为完成某一功能的程序语句的集合，称为函数。
（2）类中的函数称之方法。
2）案例实操
（1）Scala 语言可以在任何的语法结构中声明任何的语法
（2）函数没有重载和重写的概念；方法可以进行重载和重写
（3）Scala 中函数可以嵌套定义

object Test_Function {

  def main(args: Array[String]): Unit = {
    // （1）Scala 语言可以在任何的语法结构中声明任何的语法
    import java.util.Date
    new Date()

    // (2)函数没有重载和重写的概念，程序报错
    def test(): Unit = {
      println("无参，无返回值")
    }
    test()

    def test1(name: String): Unit = {
      println()
    }

    //（3）Scala 中函数可以嵌套定义
    def test2(): Unit = {
      def test3(name: String): Unit = {
        println("函数可以嵌套定义")
      }
    }
  }
}

函数定义

• 函数 1：无参，无返回值
• 函数 2：无参，有返回值
• 函数 3：有参，无返回值
• 函数 4：有参，有返回值
• 函数 5：多参，无返回值
• 函数 6：多参，有返回值

// 函数 1：无参，无返回值
def test1(): Unit = {
  println("无参，无返回值")
}
test1()

// 函数 2：无参，有返回值
def test2(): String = {
  return "无参，有返回值"
}
println(test2())

// 函数 3：有参，无返回值
def test3(s: String): Unit = {
  println(s)
}
test3("jinlian")

// 函数 4：有参，有返回值
def test4(s: String): String = {
  return s + "有参，有返回值"
}
println(test4("hello "))

// 函数 5：多参，无返回值
def test5(name: String, age: Int): Unit = {
  println(s"$name, $age")
}
test5("dalang", 40)

函数参数

• 可变参数
• 如果参数列表中存在多个参数，那么可变参数一般放置在最后
• 参数默认值，一般将有默认值的参数放置在参数列表的后面
• 带名参数

// （1）可变参数
def test(s: String*): Unit = {
  println(s)
}
// 有输入参数：输出 Array
test("Hello", "Scala")
// 无输入参数：输出 List()
test()

// (2)如果参数列表中存在多个参数，那么可变参数一般放置在最后
def test2(name: String, s: String*): Unit = {
  println(name + "," + s)
}

test2("jinlian", "dalang")

// (3)参数默认值
def test3(name: String, age: Int = 30): Unit = {
}

// 如果参数传递了值，那么会覆盖默认值
test3("jinlian", 20)
// 如果参数有默认值，在调用的时候，可以省略这个参数
test3("dalang")

// 一般情况下，将有默认值的参数放置在参数列表的后面
def test4(sex: String = "男", name: String): Unit = {
  println(s"$name, $sex")
}
// Scala 函数中参数传递是，从左到右
//test4("wusong")
//（4）带名参数
test4(name = "ximenqing")

函数至简原则

（1）return 可以省略，Scala 会使用函数体的最后一行代码作为返回值

（2）如果函数体只有一行代码，可以省略花括号

（3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）

（4）如果有 return，则不能省略返回值类型，必须指定

（5）如果函数明确声明 unit，那么即使函数体中使用 return 关键字也不起作用

（6）Scala 如果期望是无返回值类型，可以省略等号

（7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加

（8）如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略

（9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略

// （0）函数标准写法
def f(s: String): String = {
  return s + " jinlian"
}
println(f("Hello"))

// 至简原则:能省则省
//（1） return 可以省略,Scala 会使用函数体的最后一行代码作为返回值
def f1(s: String): String = {
  s + " jinlian"
}
println(f1("Hello"))

//（2）如果函数体只有一行代码，可以省略花括号
def f2(s: String): String = s + " jinlian"

//（3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略
def f3(s: String) = s + " jinlian"
println(f3("Hello3"))

//（4）如果有 return，则不能省略返回值类型，必须指定。
def f4(): String = {
  return "ximenqing4"
}
println(f4())

//（5）如果函数明确声明 unit，那么即使函数体中使用 return 关键字也不起作用
def f5(): Unit = {
  return "dalang5"
}

println(f5())

//（6）Scala 如果期望是无返回值类型,可以省略等号
// 将无返回值的函数称之为过程
def f6() {
  "dalang6"
}
println(f6())

//（7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加
def f7() = "dalang7"
println(f7())
println(f7)

//（8）如果函数没有参数列表，那么小括号可以省略,调用时小括号必须省略
def f8 = "dalang"
//println(f8())
println(f8)

//（9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略
def f9 = (x: String) => {
  println("wusong")
}

def f10(f: String => Unit) = {
  f("")
}
f10(f9)
println(f10((x: String) => {
  println("wusong")
}))