函数的声明
scala 函数通过 def 关键字定义，def前面可以具有修饰符，可以通过private、protected来控制其访问权限。
注意：没有public，不写默认就是public的。 此外也可跟上override，final等关键字修饰。
函数的返回值
函数体中return关键字往往可以省略掉，一旦省略掉，函数将会返回整个函数体中最后一行表达式的值，这也要求整个函数体的最后一行必须是正确类型的值的表达式。
大部分时候scala都可以通过 =符号 来自动推断出返回值的类型，所以通常返回值类型声明可以省略。但是注意：如果因为省略了返回值类型造成歧义，则一定要写上返回值声明。
如果函数体只有一行内容，则包裹函数体的大括号可以省略
如果返回值类型是UNIT,则另一种写法是可以去掉返回值类型和等号，把方法体写在花括号内,而这时方法内无论返回什么，返回值都是 UNIT。
格式：[private/protected] def 函数名(参数列表):返回值声明 = {函数体}
代码片段
/**
scala函数的声明和使用
知识点
1.定义一个scala函数的基本结构: def 函数名(参数列表):函数的返回值={方法体代码}
2.通用规则:scala会将方法体最后一行代码作为返回值返回,不需要加return关键字
3.通用规则:如果方法体只有一行代码,则方法体{}可以省略
4.函数默认的访问权限是public,此外也可以通过private,protected来修饰访问权限
5.函数前可以用override,final来修饰
6.scala可以根据函数的返回值自动推断出函数的返回值类型
7.注意:如果函数和方法体之间没有=,则函数的返回值类型一律为Unit(空类型)
8.scala函数支持默认参数机制,形式:
def 函数名(形参名:参数类型=默认值)={}
注意,默认值的类型要和形参类型一致
9.scala函数支持可变参数,类比于java的变长参数。形式:
def 函数名(形参名:参数类型*)={}
可变参数底层会被封装为一个集合，可以通过集合相关的操作进行操作
注意:可变参数必须位于参数列表的最后
*/
object Demo07 {
println("Welcome to the Scala worksheet") //> Welcome to the Scala worksheet
def f1(a:Int,b:Int):Int={
a+b
} //> f1: (a: Int, b: Int)Int
def f2(a:Int,b:Int):Int=a+b //> f2: (a: Int, b: Int)Int
//函数调用
f1(2,3) //> res0: Int = 5
def f3(a:Int,b:Int)={
a+b
} //> f3: (a: Int, b: Int)Int
def f4(a:String,b:Int)={
a*b
} //> f4: (a: String, b: Int)String
f4("hello",2) //> res1: String = hellohello
def f5(a:String)={
a.split(",")
} //> f5: (a: String)Array[String]
f5("hello,world") //> res2: Array[String] = Array(hello, world)
def f6(a:String){
a.split(",")
} //> f6: (a: String)Unit
//练习1:定义一个函数 f7,接收一个整型数字n,打印从0~n的所有数字
def f7(n:Int)={
for(i<-0 to n){
println(i)
}
} //> f7: (n: Int)Unit
f7(3) //> 0
//| 1
//| 2
//| 3
//scala的默认参数机制
def f8(a:String,b:String="2002")={
//返回两字符串拼接的结果
a+b
} //> f8: (a: String, b: String)String
f8("hello","world") //> res3: String = helloworld
//scala的可变参数
def f9(a:String,num:String*)={
for(i<-num){
println(i)
}
} //> f9: (a: String, num: String*)Unit
f9("hello","world") //> world
}
函数的种类
/**
知识点
1.scala的函数种类可分为4种:
①成员函数,函数定义在类的内部,作为类的成员,即为成员函数
②本地函数,定义在函数内的函数,即为本地函数
重点:③匿名函数,特点:没有函数名;通过=>来连接参数列表和方法体
关键是匿名函数的作用:
匿名函数可以当做参数进行赋值 ,比如:val f2=(a:Int,b:Int)=>{a+b}
匿名函数可以当做参数进行传递,比如:def f3(a:Int,b:Int,f:(Int,Int)=>Int)={f(a,b)}
此外,可以将匿名函数作为返回值返回
重点:④高阶函数。将函数作为参数传递的函数,即为高阶函数
2.匿名函数和高阶函数来自于面向函数的编程,面向函数的编程语言中,函数是一等公民,即函数可以赋值、传递、作为返回值返回。
3.scala语言既是面向对象的语言,也是面向函数的语言。
4.scala通用的化简规则:
①如果方法体{}只有一行代码,则{}可以省略
②当匿名函数作为参数传递时,匿名函数的参数类型可以省略
③当匿名函数作为参数传递时,如果匿名函数的参数列表只有一个参数，则参数列表的()可以省略
④最终极化简规则:通过_代替参数进行化简
*/
object Demo08 {
println("Welcome to the Scala worksheet") //> Welcome to the Scala worksheet
def f1(a:Int,b:Int)={a+b} //> f1: (a: Int, b: Int)Int
//定义一个匿名函数
(a:Int,b:Int)=>{a+b} //> res0: (Int, Int) => Int = <function2>
//将匿名函数作为参数进行赋值
val f2=(a:Int,b:Int)=>{a+b} //> f2 : (Int, Int) => Int = <function2>
f2(2,3) //> res1: Int = 5
//将匿名函数作为参数进行传递
//定义了一个高阶函数
def f3(a:Int,b:Int,f:(Int,Int)=>Int)={
f(a,b)
} //> f3: (a: Int, b: Int, f: (Int, Int) => Int)Int
f3(2,3,(a:Int,b:Int)=>{a*b} ) //> res2: Int = 6
f3(2,3,(a,b)=>a*b ) //> res3: Int = 6
f3(2,3,_*_) //> res4: Int = 6
//练习1:根据以下的调用，定义出f4函数
def f4(a:String,b:Int,f:(String,Int)=>String)={
f(a,b)
} //> f4: (a: String, b: Int, f: (String, Int) => String)String
f4("hello",3,(a:String,b:Int)=>{a*b}) //> res5: String = hellohellohello
f4("hello",3,(a,b)=>a*b) //> res6: String = hellohellohello
f4("hello",3,_*_) //> res7: String = hellohellohello
//练习2:根据以下的调用，定义出f5函数
def f5(a:String,f:(String)=>String)={
f(a)
} //> f5: (a: String, f: String => String)String
f5("file01.txt",(a:String)=>{a.dropRight(4)}) //> res8: String = file01
f5("file01.txt",(a)=>a.dropRight(4)) //> res9: String = file01
f5("file01.txt",a=>a.dropRight(4)) //> res10: String = file01
//练习3:根据以下的调用，定义出f6函数
def f6(n:Int,f:(Int)=>Unit)={
f(n)
} //> f6: (n: Int, f: Int => Unit)Unit
f6(5,(n:Int)=>{for(i<-0 to n){println(i)}}) //> 0
//| 1
//| 2
//| 3
//| 4
//| 5
f6(5,(n)=>for(i<-0 to n)println(i)) //> 0
//| 1
//| 2
//| 3
//| 4
//| 5
f6(5,n=>for(i<-0 to n)println(i)) //> 0
//| 1
//| 2
//| 3
//| 4
//| 5
val a1=Array(1,2,3,4) //> a1 : Array[Int] = Array(1, 2, 3, 4)
a1.foreach {(n:Int)=>println(n)} //> 1
//| 2
//| 3
//| 4
a1.foreach {(n)=>println(n)} //> 1
//| 2
//| 3
//| 4
a1.foreach {n=>println(n)} //> 1
//| 2
//| 3
//| 4
a1.foreach {println(_)} //> 1
//| 2
//| 3
//| 4
//练习4:根据以下的调用，定义出f7函数
def f7(a:String,f:(String)=>Array[String])={
f(a)
} //> f7: (a: String, f: String => Array[String])Array[String]
f7("hello,world",(a:String)=>{a.split(",")}) //> res11: Array[String] = Array(hello, world)
f7("hello,world",a=>a.split(",")) //> res12: Array[String] = Array(hello, world)
f7("hello,world",_.split(",")) //> res13: Array[String] = Array(hello, world)
}
