Scala---函数

一、普通函数

def showMe(name:String,age:Int):String={
      "my name is "+name+"\tage is "+age
    }

val sho = showMe("Tom",34)              //按照顺序---传参
println(sho)

val sho1= showMe(age=12,name="hel")     //指定形参名---传参
println(sho1)

【注意：函数中只有一条语句可以省略{}】

def sum(a:Int,b:Int):Int = a+b        //普通函数 --- 函数中只有一条语句可以省略{}
println(sum(3,-2))

1、比较两个数大小

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

2、可变长度参数

可变长度的参数，将值放入到Vector集合中

  // 可变长度参数,装在一个Array中
    def getMe(name:String,s:String*):Unit={
      println(name)
      for(str<- s){
        println(str)
      }
    }
    getMe("To","ss","gg")

二、匿名函数

val x = (a:Int,b:Int)=>a+b          //匿名函数
val asd : (Int,Int)=>Int = (a:Int,b:Int)=>a+b   //匿名函数加上声明
val asd2 : (Int,Int)=>Int = sum     //调用已定义的函数
println(x(10,9))					//调用
println(asd(10,9))

三、递归函数

// 递归 --- 阶层
def Jiecen(x:Int):Int={
	if(x==1 || x==0)		//定义递归结束
		1
	else{
		 x*Jiecen(x-1)
	 }
 }
val ss = Jiecen(0)
println(ss)

四、高阶函数

函数作为参数或者输出

1、函数作为参数

def funtest(f:(Int,Int)=>Int,mess:String):String={  //函数传递函数
        val a=90
        val b=78
        f(a,b)+mess
     }
val s= funtest((a,b)=> a+b ,"和")           //调用时，直接在实参中定义匿名函数
val s1= funtest((a,b)=> a*b ,"积")
println(s)

2、函数作为返回值

def funTest2():(String,String)=>String={      //函数返回值是个函数
     (a:String,b:String)=>a+b
}
println(funTest2()("sc","ge"))

3、函数作为参数和返回值

def f1(a:Int,b:Int,func:(Int,Int)=>Int):(Int,Int)=>Int={
 if(func(a,b)%2==0){
    (m1,m2)=>m1+m2
  }else{
    (m1,m2)=>m1-m2
  }
}
println(f1(2,3,(a,b)=>a*b)(45,23))

五、柯里化

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

	def fun(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
    }
    def fun3(a:Int)(b:Int)(c:Int)(d:Int):Int={
      a+b+c+d
    }
    println(fun(3,4,5,6))
    println(fun2(2,3)(3,4))
    println(fun3(2)(3)(4)(5))

六、隐式转化

关键字：implicit

• 隐式参数
• 隐式函数
• 隐式类

隐式参数

方法可以具有隐式参数列表，由参数列表开头的implicit 关键字标记
多于柯里化同时使用

// 隐式转换调用方法时 --- 优先级：实参 > 隐式（本类 > 其他类） > 默认
implicit val num:Int = 10     //一个作用域内只能有一个相同类型的隐式参数
implicit val na :String = "Tom"
def sum(a:Int)(implicit b:Int=5,name:String):Int={		//隐式参数，注意看柯里化
  println(name)
  a+b
}
println(sum(20))
println(sum(20)(20,"Jack"))
println(sum(20)(name ="",b = 3))

隐式函数

implicit  def DoubleToInt(value:Double):Int=value.toInt
val a:Int = 34.2		//正常这么定义会报错，但是定义了上面的隐式函数，就可以默认转成对应的类型
println(a)

隐式类

用implicit关键字修饰的类，其主构造器可用于隐式转换

只能在类、Trait、对象（单例对象、包对象）内部定义
构造器只能携带一个非隐式参数
隐式类不能是case class
在同一作用域内，不能有任何方法、成员或对象与隐式类同名

object Implicteg {
implicit class NumberOper(demo1: Demo1){
    def sum(a:Int,b:Int):Int={
      println("a ="+a+"\tb = "+b)
      a+b
    }
  }
  implicit class NumOper2(demo1: Demo1){
    def sub(a:Int,b:Int):Int={
      println("a = "+a+"\tb="+b)
      a-b
    }
  }
}

import Implicteg._

class Demo1{}

object Demo1 {
  def main(args: Array[String]): Unit = {
  	println(new Demo1().sum(2,4))			//本类中没有定义该方法，就可以通过隐式类获取之
    println(new Demo1().sub(4,2))
  }
}

七、偏函数

偏函数是只对函数定义域的一个子集进行定义的函数
PartialFunction[-A,+B]是一个特质

// 偏函数 --- 类似于 Java 中的 switch case,只不过Java中的不支持String类型
def funPartition:PartialFunction[String,Int]={   //输入为String,
  case "hello"=> 1
  case "world"=> 2
  case _=>3
}
val i = funPartition("hello")
println(i)

def funPartition2:PartialFunction[Int,String]={
  case 1 => "优秀"
  case 2 => "良好"
  case 3 => "及格"
  case _=> "不行啊"
}
println(funPartition2(4))

def sexpartialFunction: PartialFunction[String,Int]={
  case "male" |"男"=> 1
  case "female" | "女"=> 0
  case _=> 9999
}
println(sexpartialFunction("男"))
var arr=Array(1,2,3)
for(x<- arr){
  println(funPartition2(x))
}
val strs:Array[String] = arr.collect(funPartition2)

八、部分函数

def sumResult(a:Int,b:Int):Int= a+b
val num1 = 7
def sum=sumResult(num1,_:Int)   //部分值传入，注意：类型别忘了加
println(sum(3))            	    //只写未传入的参数
def showMes(title:String,content:String,height:Double)={
  println(title+" "+content+" "+height)
}
showMes("警告","当前水位高",34.3)
val title:String = "警告"
def showAlarm=showMes(title,_:String,_:Double)

九、模式匹配

match 类似于Java中的 switch,但支持所有类型
不需要 break
能够生成返回值
_ :代表默认值

//模式匹配
def match1(x:Int):String= x match {
  case 1 => "one"
  case 2 => "two"
  case _ => "many"
}
def match2(x:Any):Unit = x match {
  case 1 => println("内容为1")
  case x:Int => println("类型为Int,值为 "+x)  //...
  case _ => println("无效内容")
}