scala函数、匿名函数、柯里化、隐式函数、隐式参数、隐式类

Scala函数

语法

def main(args: Array[String]): Unit = {}
//def 声明函数 main函数名称 args 形参 
//Array[String] 类型  Unit 返回值

需求：两数的最小值

def minValue(a:Int,b:Int): Int ={
  if(a > b) b else a
}
val result = minValue(11,13)
println(result)

def info(name:String,age:Int): String = {
  s"我的名字是：$name,年龄是：$age"
}
println(info("zzz","18"))

递归函数

def ji(n:Int):Int = {
  if(n==1) 1 else n * ji(n-1)
}
println(ji(5))

指定形参名字传参

def showMsg(name:String,age:Int):String = {
  println(s"hello$name,age:$age")
}
println(showMsg("zzz",18))
println(showMsg(age=18,name="zzz"))

通过*来指定未知长度的参数

def showMsg(name:String,s:String*): Unit={
  println(name)
  println(s.getClass)//数组
  for (elem <- s){
    println(elem)
  }
  println("--------")
}
showMsg("zzz")
showMsg("zzz","1")
showMsg("zzz","1","2","3")

匿名函数

匿名函数：不含函数名称的函数
表示创建一个函数实例

(x: Int) => x + 1
//可以这么理解 左边是输入参数  Int是参数类型
//右边当做是函数体 类似java的{.....}
//与下面的java方法表示的含义一样
public int functiong(int x){
	return x + 1;
}

1、将函数赋值给变量

def sum(a:Int,b:Int): Int = a + b
val abc = (a:Int,b:Int) => a+b
val cba = abc
println(sum(1,2))
println(abc(1,2))
println(cba(1,2))

2、在Scala中，函数就像普通变量一样，同样具有函数的类型

val  a  :       Int      =  21
val abc1: (Int,Int) =>Int = (a:Int,b:Int) => a-b
def sum(a:Int,b:Int): Int = a + b
val abc2: (Int,Int) =>Int = abc1
val abc3: (Int,Int) =>Int = sum
println(abc1(10,2))
println(abc2(11,2))
println(abc3(12,2))

3、函数作为参数传递

def funcTest(f:(Int,Int)=>Int,msg:String):String={
  val a = 100
  val b = 50
  msg + f(a,b)
}
def sum(a:Int,b:Int):Int = a+b
println(funcTest(sum,"和："))
println(funcTest((a:Int,b:Int)=> a+b,"和："))

4、函数作为返回值

//方法一
def fun():(String,String)=>String ={
  def funDemo(a:String,b:String):String ={
    a+b
  }
  return funDemo
}
//方法二
def fun1():(String,String)=>String={
  (a:String,b:String)=>a+b
}
println(fun()("zzz","51"))
println(fun1()("zzz","1108"))

例子：

def fun(f:(Int,Int)=>Int,num1:Int,num2:Int):(Int,Int)=>Int ={
  val result = f(num1,num2)
  if(result%2==0){
    (a,b)=>a+b
  }else{
    (a,b)=>a-b
  }
}
println(fun((a,b)=>a*b,10,15)(98,97))
//195

函数柯里化

方法可以定义多个参数列表，当使用较少的参数列表调用多参数列表的方法时，会产生一个新的函数，该函数接收剩余的参数列表作为其参数。这被称为柯里化

def fun(a:Int,b:Int,c:Int,d:Int):Int ={
  a+b+c+d
}
def fun1(a:Int,b:Int)(c:Int,d:Int):Int ={
  a+b+c+d
}
def fun2(a:Int,b:Int,c:Int)(d:Int):Int = {
  a+b+c+d
}
println(fun(1,2,3,4))
println(fun1(1,2)(3,4))
println(fun2(1,2,3)(4))
//10
//10
//10

隐式函数

应用场景：类型转换

implicit def stringToInt(value:String):Int = Integer.parseInt(value)
val a: Int = "3"
implicit def doubleToInt(value:Double):Int = value.toInt
val b: Int = 3.5
println(a) //3
println(b) //3
implicit def intToString(value:Int):String = {
  println("传入的数据是："+value)
  value.toString+"zzz"
}
val c: String = 456
println(c)

隐式参数

方法可以具有隐式参数列表，由参数列表开头的implicit关键字标记
通常与柯里化函数结合使用

implicit val num:Int = 10
def sum(a:Int)(implicit b:Int):Int = {
  a+b
}
println(sum(20))          //30 
println(sum(20)(30))      //50
def sum1(a:Int)(implicit b:Int=5):Int = {
  a+b
}
println(sum1(20))         //30

def sum1(a:Int)(implicit b:Int=5):Int = {
  a+b
}
println(sum1(20))      //25

调用方法的时候，传参的优先级>隐式值>默认值(implicit b:Int = 5)

隐式类

使用implicit声明的类，可以扩展类的功能

class Demo1{}
object Demo1{
  def main(args: Array[String]):Unit = {
     implicit class operation(demo:Demo1){
       def sum(a:Int,b:Int):Int = {
         println("a value"+a)
         println("b value"+b)
         a+b
       }
    }
    val demo1 = new Demo1
    println(demo1.sum(2,5))//扩展的功能
  }
}

其所带的构造参数有且只能有一个
隐式类必须被定义在“类”或“伴生对象”或“包对象”里，即隐式类不能是 顶级的(top-level-objects)。
举例

implicit class cal(x:Int){
  def add(a:Int):Int ={
    a+x
  }
}
println(2.add(3))   //此时Int类型的2 已经多了add方法  5