函数式编程
Scala也是一种函数式编程语言，其函数也能当成值来应用。Scala提供了轻量级的语法用以定义匿名函数，反对高阶函数，容许嵌套多层函数，并反对柯里化。Scala的case class及其内置的模式匹配相当于函数式编程语言中罕用的代数类型。
在Scala中，存在办法和函数两个概念，办法和函数在语义上区别很细小。
Scala 中的办法跟 Java 的相似，办法是组成类的一部分。scala 中的函数则是一个残缺的对象。
Scala中办法和函数在语法上区别不大，只是类中申明的函数咱们叫办法，办法有重载和重写，而函数则没有。
1.一般函数编程
1.1 根本语法
[修饰符] def 函数名 ( 参数列表 ) [:返回值类型] = {
函数体
}示例
object Scala_Fun {
def main(args: Array[String]): Unit = {
test("hello")
}
/**
* 一般函数示例
* @param str
*/
private def test(str:String):Unit = {
println(str)
}
}1.2 函数定义
object Scala_Fun {
def main(args: Array[String]): Unit = {
// 无参，无返回值
def fun1(): Unit ={
println("无参且无返回值")
}
// 无参，有返回值
def fun2(): String ={
// 能够省略return
"张三"
}
// 有参，无返回值
def fun3(str:String): Unit ={
println(str)
}
// 有参，有返回值
def fun4(str:String): String ={
"hello:"+ str
}
// 关键字参数
}
}1.3 函数参数
object Scala_Fun {
def main(args: Array[String]): Unit = {
// 可变参数
def fun1(names:String*): Unit ={
println(names)
}
fun1("张三","李四")
// 可变参数不能搁置在参数列表的后面，个别放在参数列表的最初
// 如果学过python，会发现传参这里跟python传参很类似
/* 谬误示范
def fun2(names:String*, count:Int): Unit ={
}*/
def fun2(count:Int,names:String*): Int ={
println(names)
count
}
// 参数默认值
def fun3(name:String, age:Int = 18): Unit ={
println(name+ ":" + age)
}
// 命名传参
fun3(name="张三")
}
}1.4 函数精简准则
object Scala_Fun {
def main(args: Array[String]): Unit = {
// Scala中函数能够进行精简，所谓是能省则省，当然前提是编译器能够主动推断
def fun1(name:String): String ={
return "姓名:"+name
}
// 1.当函数有返回值时，能够将函数体中最初一行执行的代码作为返回后果，所以能够省略return关键字
def fun2(name:String): String ={
"fun2:"+name
}
println(fun2("张三"))
// 2.如果编译器能够推断出函数的返回值类型，返回值类型则能够省略
def fun3(name:String)={
"fun3:"+name
}
println(fun3("张三"))
// 3.如果函数体逻辑只有一行代码，则函数体的大括号能够省略
def fun4(name:String) = "fun4:"+name
println(fun4("张三"))
// 4.如果函数没有参数，调用时候，小括号能够省略
def fun5(): String ={
"fun5"
}
println(fun5)
// 5.如果函数没有提供参数，那申明时，小括号能够省略，调用时，也不能应用小括号
def fun6 = "fun6"
println(fun6)
// 6.如果函数应用Unit申明没有返回值，那函数体中的return关键字不会起作用。
/*
def fun7():Unit={
return "张三"
}*/
// 7.函数体中如果应用return关键字，则返回值不能省略
def fun8():String = {
"fun8"
}
// 8.如果函数没有返回值，Unit又不想用，那能够同时省略等号，但保留花括号
def fun9(){
println("张三")
}
// 9.匿名函数：当只关怀代码逻辑，不关怀函数名时，则函数名和def关键字能够省略
// 匿名函数规定： (参数列表) => {函数逻辑}
val fun10 = (name:String)=>println(name)
fun10("张三")
}
}2.高阶函数编程
2.1什么是高阶函数和柯里化Currying
1）数学概念
回顾下数学知识：
y=f(x) 这是最开始接触的一般函数
y=g(f(x)) 这个就是咱们接触到的高阶函数在数学和计算机科学中，高阶函数至多该当是满足上面一个条件的函数：
1）承受一个或者多个函数作为参数
2）输入一个函数程序中咱们的高阶函数也相似
2）柯里化Currying
柯里化：指的是将原来承受两个参数的函数变成新的接管一个参数的函数,新的函数返回一个以原有第二个参数为参数的函数
z = f(x, y)转换成z=f(x)(y)
2.2 函数作为值
object Scala_Fun {
def main(args: Array[String]): Unit = {
def fun1():String = {
"张三"
}
val v1 = fun1() // 调用函数，把函数的返回后果赋值给变量v1
val v2 = fun1 _ // 把函数作为值赋值给变量v2
println(v1)
println(v2)
}
}2.3 函数作为参数
object Scala_Fun {
def main(args: Array[String]): Unit = {
def fun1():String = {
"张三"
}
def fun2(fun:()=>String): Unit ={
println(fun())
}
fun2(fun1)
}
}2.4 把函数作为返回值
object Scala_Fun {
def main(args: Array[String]): Unit = {
def fun1():String = {
"张三"
}
def fun2() = {
fun1 _
}
println(fun2()())
}
}2.5 闭包
函数在应用内部变量时，如果内部变量生效时，会将这个变量蕴含到以后的函数外部，造成闭合的成果，这个就是闭包。
匿名函数自身就是一种闭包。
代码示例
object Scala_Fun {
def main(args: Array[String]): Unit = {
def outFun(i:Int) ={
def inFun(j:Int) = {
i + j
}
inFun _
}
val res = outFun(10)(10)
println(res)
}
}2.6 惰性函数
惰性函数，也就是提早加载，直到咱们首次对此取值，该函数才会执行，应用lazy关键字申明其返回值时，就会造成惰性函数。
示例：
object Scala_Fun {
def main(args: Array[String]): Unit = {
def fun():String = {
println("张三")
"张三"
}
lazy val res = fun()
println(res)
}
}2.7 函数柯里化
object Scala_Fun {
def main(args: Array[String]): Unit = {
// 应用柯里化形式申明函数
def fun1(a:Int,b:Int,f:(Int,Int)=>Int):Unit = {
}
def fun2(a:Int)(b:Int)(f:(Int,Int)=>Int) = {
f(a,b)
}
// 调用函数
println(fun2(10)(20)(_ + _))
}
}学过Python的话，会发现这里的高阶函数和Python的高阶函数大同小异。
发表回复