可变参数:
-
def f4(str:String*): Unit = {}。
-
如果除了可变参数还有其他参数,需要将可变参数放在末尾。
-
可变参数当做数组来使用。
object test_02_comment {
def main(args: Array[String]): Unit = {
def f4(str:String*):Unit={
println(str)
}
f4(“sandrew”)
f4(“sandrew”,“coco”)
}
}output:
ArraySeq(sandrew)
ArraySeq(sandrew, coco)
参数默认值:
-
def f5(name: String = “alice”): Unit = {}
-
和C++一样,默认参数可以不传,默认参数必须全部放在末尾。
object test_02_comment {
def main(args: Array[String]): Unit = {
def f4(str:String = “alice”):Unit={
println(str)
}
f4(“sandrew”)
f4()
}
}
output:
sandrew
alice
带名称传参:
-
调用时带名称。
object test_02_comment {
def main(args: Array[String]): Unit = {
def f6(name: String, age: Int = 20, loc: String = “BeiJing”): Unit = {
println(s"name ${name}, age ${age}, location ${loc}")
}f6("Bob") f6("Alice", loc = "Xi'An") f6("Michael", 30) }
}
output:
name Bob, age 20, location BeiJing
name Alice, age 20, location Xi’An
name Michael, age 30, location BeiJing
函数至简原则:
def f0(name: String) : String = {
return name
}
1.省略return,scala会使用函数体最后一行代码作为返回值
def f0(name: String) : String = {
name
}
2.如果函数体中只有一行代码,可以省略{}
def f0(name: String) : String = name
3.如果返回值类型能够推断出来,那么可以省略: 返回值
def f0(name: String) = name
类似于数学中的f(x)=x
4.如果无返回值,则可以省略等号
def f1(name:String) = {
println(name)
}
def f1(name:String) {
println(name)
}
5.如果函数无参,但是声明了参数列表,那么调用时,小括号可以省略
def f1() : Unit = {
println("sandrew")
}
f1()
f1 //效果和f1()一样
但是如果声明的时候没有写(),调用的时候也不能加()
def f1 : Unit = {
println("sandrew")
}
f1() //报错
f1 //只能用这种方式调用
6.如果不关心名称,只关心处理逻辑,那么函数名(def)可以省略 -》》》即匿名函数
def f3(name: String): Unit = {
println(name)
}
===》
(name:String) => { println(name) }
匿名函数 lambda
(x:Int)=>{函数体}
val fun = (name: String) => {println(name)}
fun("sandrew")
匿名函数一般是作为参数输入
object test_02_comment {
def main(args: Array[String]): Unit = {
val fun = (name: String) => {println(name)}
def f(func: String => Unit) : Unit = {
func("sandrew")
}
f(fun) // 与下面等效
f((name: String) => {println(name)})
//匿名函数的简化原则
// 1.参数类型可以省略,会根据形参进行自动推导
f((name) => {println(name)})
// 2.如果只有一个参数,则()可以省略
f(name => {println(name)})
// 3.匿名函数只有一行,则{}可以省略
f(name => println(name))
// 4.如果参数只出现一次,则参数省略,且后面参数可以用_代替
f(println(_))
// 5.如果可以推断出,当前出入的println是一个函数体,而不是调用语句,可以省略下划线
f(println)
}
}
object test_02_comment {
def main(args: Array[String]): Unit = {
// 定义一个二元运算函数,只操作1,2两个数,但是具体运算通过参数传入
def dualFunc(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(dualFunc(add)) // 3
println(dualFunc(minus)) // -1
}
}
//匿名函数简化
// 1.不用定义变量,直接在调用处使用匿名函数
println(dualFunc((a:Int, b:Int) => a+b)) // 3
println(dualFunc((a:Int, b:Int) => a-b)) // -1
//2.参数的类型不需要写,因为已经在dualFunc的形参中定义好了
println(dualFunc((a, b) => a + b)) // 3
println(dualFunc((a, b) => a - b)) // -1
//3.因为有两个参数,所以()不能删,由于a和b一次,所以可以用_代替
println(dualFunc(_ + _)) // 3
println(dualFunc(_ - _)) // -1
高阶函数
函数作为值传递
def f(n:Int): Int = {
println("f调用")
n+1
}
// 1.函数作为值进行传递
val f1 = f _
val f2: Int=>Int = f //可以把“ _”省略,因为前面声明了f2的类型
println(f1) // test_02.test_02_comment$$$Lambda$3/466002798@387c703b
println(f1(12))
/*
f调用
13*/
println(f2) // test_02.test_02_comment$$$Lambda$4/33524623@224aed64
println(f2(35))
/*
f调用
36*/
函数作为函数的参数传递
def dualOp(op: (Int,Int)=>Int, a:Int, b:Int): Int = {
op(a,b)
}
def add(a:Int, b:Int): Int = {
a + b
}
println(dualOp(add, 12, 35))
println(dualOp((a, b)=>{a+b}, 12, 35))
println(dualOp(_+_, 12, 35))
函数作为函数的返回值返回
object test_02_comment {
def main(args: Array[String]): Unit = {
def f5(): Int => Unit = {
def f6(a: Int): Unit = {
println("f6调用: " + a)
}
f6
}
println(f5()) // test_02.test_02_comment$$$Lambda$3/225493257@629f0666
}
}