方式一：
(函数的参数列表) => 函数体
val add = (x: Int, y: Int) => x + y

方式二：
(函数的参数类型列表)=> 函数的返回值类型 = (函数的参数变量引用) => 函数体
val add:(Int, Int) => Int = (a, b) => a + b
val prtf: String => Unit = msg => println(msg)

def f3()={ 100 } //> f3: ()Int 。scala可以根据返回值自动推断出函数的类型，不需要显示声明

def f5(){ 100 } //> f5: ()Unit scala函数如果没有=号，则返回值类型一律为Unit(),所以建议写函数时，别忘了加=

def f8(a:String,b:String="?")={ a+b } //--scala函数的默认参数机制，任何类型都可以使用默认参数机制

def f（str: String, a: Any*） //--scala也支持可变参数,可变参数本质会转成集合类型,注意:可变参数必须位于参数列表的最后

柯里化技术

1.scala底层支持柯里化技术，允许将接收多个参数的函数转变为接收单一参数的函数

2.scala的柯里化技术允许用户自建立控制结构。柯里化技术是函数式编程语言的技术

def method4(a: Int)(b: Int, c: Int) method(0)(4, 5)

//--自建的控制结构：重点留意这种形式,前面的参数都是普通参数，后面的参数是匿名函数
def f32(a:Int,b:Int)(f:(Int,Int)=>Int){f(a,b)} //> f32(2,3)(_+_)
def f33(a:Int)(b:Int,f:(Int,Int)=>Int){f(a,b)} //> f33: (a: Int)(b: Int, f: (Int, Int) => Int)Unit

偏函数

PartialFunction[参数类型，函数返回值类型]
def method5 :PartialFunction[Any, String] = {
case x: Int => x * 10
}

成员函数和本地函数

class Person {

//--定义在类内部的函数，称为成员函数

def say()={

println("hello")

//--定义在函数内的函数，成为本地函数，本地函数无法通过对象直接调用

def speak()={

println("say world")

}

}

}

匿名函数和高阶函数

1.scala语言既是面向对象的语言，也是面向函数的语言(函数是一等公民)、

2.匿名函数通用的化简规则1:如果参数的类型可以推断出，则类型可以省略

2:如果匿名函数的参数只有一个，则参数的()可以省略
def f1(a:Int,b:Int)={a+b} //--定义普通函数 > f1: (a: Int, b: Int)Int
val f2=(a:Int,b:Int)=>{a+b} //--定义匿名函数,匿名函数没有函数名,匿名函数和方法体的连接符是 =>，把匿名函数赋值给f2,

def f3(a:Int,b:Int,f:(Int,Int)=>Int)={ //--把匿名函数当做参数进行传递，此函数称为高阶函数,这是函数式编程的特点
f(a,b)
}
//--要求调用f3,完成2*3的计算
f3(2,3,(a:Int,b:Int)=>{a+b}) //> res1: Int = 5
f3(2,3,(a,b)=>a+b) //> res2: Int = 5
f3(2,3,_+_) // 最终极的化简规则：可以通过_(占位符)来化简。可以通过_来代替参数 ,Int = 5

fllter和foreach

val a1=Array(1,2,3,4) //> a1 : Array[Int] = Array(1, 2, 3, 4)
a1.filter {(x:Int)=>{x>2} } //--通过指定的匿名函数实现过滤 //> res9: Array[Int] = Array(3, 4)
a1.filter {x=>x>2 } //> res10: Array[Int] = Array(3, 4)
a1.filter {_>2 } //> res11: Array[Int] = Array(3, 4)
a1.foreach { (x:Int) =>{println(x)} } //--通过指定的匿名函数遍历数组 //> 1 2 3 4
a1.foreach { x=>println(x) } //> 1 2 3 4
a1.foreach { println(_) } //> 1 2 3 4

递归函数

1.scala写递归函数，必须显示的声明函数的返回值类型，不能用自动推断

2.写递归的技巧:掌握两要素 ①找出递归函数的结束条件 ②找出函数关系(重点)

3.scala的递归函数，结束条件的返回值必须加return关键字返回

//--用递归函数判断斐波那契数列第n项的数字是多少
//--2 3 5 8 13
//--函数关系:f(n)=f(n-1)+f(n-2)
//--结束条件:f(0)=2 f(1)=3

def f1(n:Int):Int={
   if(n==0) return 2
   if(n==1) return 3
   else f1(n-1)+f1(n-2)
}