函数式编程基础

一、函数和方法的区别

1、核心概念

    （1）未完成某一功能的程序语句的集合，称为函数。

    （2）类中函数称之为方法。

 

例子：

object functionAndMEthod {
  def main(args: Array[String]): Unit = {
    //定义函数
    def sayHi(name: String): Unit ={
      println("hi," + name)
    }
    //调用函数
    sayHi("wl")

    //调用对象方法
    functionAndMEthod.sayHi("wll")

    //获取方法返回值
    val result = functionAndMEthod.sayHello("xw")
    println(result)
  }

  //定义对象的方法
  def sayHi(name: String): Unit ={
    println("Hi," + name)
  }

  def sayHello(name: String): String ={
    println("hello," + name)
    return "hello"
  }

}

编译：

 

 

 

 

二、函数定义

1、无参，无返回值

//1、无参， 无返回值
    def f1(): Unit ={
      println("1、无参， 无返回值!")
    }
    f1()
    println(f1())

 

 

 

2、无参，有返回值

//2、无参， 有返回值
    def f2(): Int ={
      println("2、无参， 有返回值")
      return 22
    }
    println(f2())

 

 

 

3、有参， 无返回值

def f3(name: String): Unit ={
      println("3、有参， 无返回值" + name)
    }
    //输出为（）
    println(f3("wl"))

 

 

 

4、有参， 又返回值

 //4、有参， 有返回值
    def f4(name: String): String ={
      println("4、有参， 有返回值" + name)
      return "hi" +name
    }
    println(f4("wll"))

 

 

 

5、多参， 无返回值

//5、多参， 无返回值
    def f5(name1: String, name2: String ): Unit ={
      println("5、多参， 无返回值" )
      println(s"${name1}和${name2}都是我")
    }
    println(f5("dw", "xw"))

 

 

6、多参， 又返回值

//6、多参， 有返回值
    def f6(a: Int, b: Int): Int = {
      println("6、多参， 有返回值")
      return a + b
    }
    println(f6(10, 12))

 

 

 

 三、函数参数

1、可变参数

//1、可变参数
    def f1(str: String*): Unit = {
      println(str)
    }
    f1("sy")
    f1("wl", "xw", "dw")

 

 

 

2、如果参数列表中存在多个参数，那么可变参数一般放置在最后

//2、如果参数列表中存在多个参数，那么可变参数一般放置在最后
    def f2(str1: String, str2: String*): Unit = {
      println("str1" + str1 + "str2" + str2)
      f2("syy")
      f2("aaa", "bbb", "ccc", "ddd")
    }

 

3、参数默认值，一般将有默认值的参数放置在参数列表的后面

//3、参数默认值，一般将有默认值的参数放置在参数列表的后面
    def f3(name: String = "xwtx"): Unit = {
      println("My name is :" + name)
    }
    f3("wl")
    f3()

 

 

 

4、带名参数

//4、带名参数
    def f4(name: String,age: Int): Unit = {
      println(s"${age}岁的${name}")
    }
    f4("wwll", 22)
    //打乱顺序
    f4(age = 22, name = "wwl")

 

 

 

四、函数至简原则

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

def f1(name: String): String = {
      name
   }
    println(f1("wl"))

 

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

//2、如果函数体只有一行代码，可以省略花括号
    def f2(name: String): String = name
    println(f2("wl"))

 

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

def f3(name: String) = name
    println(f3("wl"))

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

 

5、如果函数声明Unit，那么即使函数体使用return关键字也不起作用

 

6、scala如果期望是无返回值，可以省略等号

def f6(name: String) {
      println(name)
    }
    println(f6("wl"))

 

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

def f7(): Unit = {
      println("wll")
    }
    f7

 

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

def f8: Unit = {
    }
    f8

 

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

def f9(name: String): Unit = {
      println("wll")
    }
        //匿名函数，或者叫lambda表达式
    (name: String) => {println(name)}

 

五、匿名函数的简化原则

val fun = (name: String) => {println(name)}
    fun("wl")

    //定义一个函数，以函数作为参数输入
    def f(func: String => Unit): Unit = {
      func("wll")
    }
    f(fun)

 

1、参数的类型可以省略，会根据形参进行自动的推导

f( (name) => {
      println(name)
    })

 

2、类型省略之后，发现只有一个参数，则圆括号可以省略，没有参数和参数超过1的永远       不能省略圆括号

f( name => {
      println(name)
    })

 

3、匿名函数如果只有一行，则大括号也可以省略

f( name => println(name))

 

4、如果参数只出现一次，则参数省略且后面参数可以用 _ 代替

f(println(_))

 

 

5、如果可以推断出当前传入的println是一个函数体而不是调用语句，可以直接省略下划线

f(println)

 

例子：

//实际示例： 定义一个“二元运算”函数，只操作1和2两个数，但是具体运算通过参数传入
    def OneAndTwo(fun: (Int, Int) => Int): Int ={
      fun(1, 2)
    }

    val add = (a: Int, b: Int) => a + b
    val minus = (a: Int, b: Int) => a - b
    println(OneAndTwo(add))
    println(OneAndTwo(minus))

    //匿名函数简化
    println(OneAndTwo(_+_))
    println(OneAndTwo(_-_))