在Scala中，方法和函数几乎可以等同(比如它们的定义、使用、运行机制都是一样的)，只是函数的使用方式更加的灵活多样。函数式编程是从编程方式(范式)的角度来谈的，可以这样理解：函数式编程把函数当作一等公民，充分利用函数、只是函数的多种使用方式，在Scala中，函数是一等公民，像变量一样，既可以作为函数的参数使用，也可以将函数赋值给一个变量，函数的创建不用依赖于类或者对象，而在Java当中，函数的创建则要依赖于类、抽象类或者接口。在Scala中函数式编程和面向对象编程融合在一起了。
1.函数式编程
函数式编程是一种编程范式(programming paradigm)。
函数式编程属于“结构化编程”的一种，主要思想是把运算过程尽量写成一系列嵌套的函数调用。
函数式编程中，将函数也当做数据类型，因为也可以接受函数当作输入(参数)和输出(返回值)。
函数式编程中，最重要的就是函数。
2.函数形式
def 函数名([参数名:参数类型],…)[[:返回值类型]=] {
语句…
return 返回值
}
# =表示返回值类型不确定，需要类型推导完成
def getRes(n1: Int, n2: Int, oper: Char) = {
if (oper == '+') {
n1 + n2 //返回
} else if (oper == '-') {
n1 - n2
} else {
//返回null
null
}
}
A.可以根据函数体最后一行代码自行推断函数返回值类型
def getSum(n1: Int, n2: Int): Int = {
n1 + n2
}
** 最后一个表达式即为函数返回值**
如果函数没有形参，调用时可以不带()
B.如果函数明确使用return关键字，那么函数返回就不能使用自行推断了，这时要明确写成 : 返回值类型 = ，当然，如果什么都不写，即使有return返回值也为()
package hello
/**
* @author Administrator
* @date 2020/2/16 9:29
*/
object Test1 {
def main(args: Array[String]): Unit = {
# 输出（）
print(fun1(1, 2))
# 输出3
print(fun2(1, 2))
}
def fun1(i: Int, j: Int) {
return i + j
}
def fun2(i: Int, j: Int): Int = {
return i + j
}
}
C.函数嵌套
object boke_demo01 {
def main(args: Array[String]): Unit = {
def f1(): Unit = { //ok private final
println("f1")
}
println("ok~~")
def sayOk(): Unit = { // private final sayOk$1 ()
println("main sayOk")
def sayOk(): Unit = { // private final sayOk$2 ()
println("sayok sayok")
}
}
}
def sayOk(): Unit = { //成员
println("main sayOk")
}
}
D.函数参数默认值
object boke_demo01 {
def main(args: Array[String]): Unit = {
println(sayOk("mary"))
}
//name形参的默认值jack
def sayOk(name: String = "jack"): String = {
return name
}
}
E.函数带名参数
object boke_demo01 {
def main(args: Array[String]): Unit = {
// mysqlCon()
// mysqlCon("127.0.0.1", 7777) //从左到右覆盖
//如果我们希望指定覆盖某个默认值，则使用带名参数即可,比如修改用户名和密码
mysqlCon(user = "tom", pwd = "123")
//f6("v2") // (错误)
f6(p2 = "v2") // (?)
}
def mysqlCon(add: String = "localhost", port: Int = 3306,
user: String = "root", pwd: String = "root"): Unit = {
println("add=" + add)
println("port=" + port)
println("user=" + user)
println("pwd=" + pwd)
}
def f6(p1: String = "v1", p2: String) {
println(p1 + p2);
}
}
F.递归函数未执行之前是无法推断出来结果类型，在使用时必须有明确的返回值类型
def f8(n: Int) = { //?错误，递归不能使用类型推断，必须指定返回的数据类型
if (n < 0)
1
else
n * f8(n - 1)
}
G:函数可变参数
//支持0到多个参数
def sum(args : Int*) : Int = {
}
//支持1到多个参数
def sum(n1 : Int, args : Int*) : Int = {
}
3.特殊函数形式过程（procedure）
def f10(name: String): Unit = {
println(name + “hello”)
}
如果函数声明时没有返回值类型，但是有等号(=)，可以进行类型推断最后一行代码。这时这个函数实际是有返回值的，该函数并不是过程。
4.惰性函数
当函数返回值被声明为lazy时，函数的执行将被推迟，直到首次对此取值，该函数才会执行，这种函数称之为惰性函数。
object boke_demo01 {
def main(args: Array[String]): Unit = {
lazy val res = sum(10, 20)
println("-----------------")
println("res=" + res) //在要使用res 前，才执行
}
//sum函数，返回和
def sum(n1: Int, n2: Int): Int = {
println("sum() 执行了..") //输出一句话
return n1 + n2
}
}
lazy不能修饰var类型的变量, 不但是在调用函数时，加了lazy，会导致函数的执行被推迟，在声明一个变量时，如果给声明了lazy，那么变量值的分配也会推迟。
————Blueicex 2020/2/15 18:06 [email protected]
