＜Zhuuu_ZZ＞Scala(四)高阶函数

嵌套函数

两层嵌套

• 需求：输入一个字符串，判断这个字符串的长度跟5的大小分别输出两个数不同的结果

object Test1 {
  def main(args: Array[String]): Unit = {
    //第一种方法：先判断后内置函数
//    def fun(s: String): (Int, Int) => Int = {
//      if (s.length > 5) {
//        def add(a: Int, b: Int): Int = {
//          a + b
//        }
//        add
//      } else if (s.length == 5) {
//        (a: Int, b: Int) => a - b
//      } else {
//        _ * _
//      }
// println(fun("hahah")(9, 1))
    
    //第二种方法：先内置函数后判断。基于所用的内置函数是一个结构
      def fun(s:String):(Int,Int)=>Int={
      def suanfa(a:Int,b:Int):Int={
       if(s.length>5)a+b
       else if(s.length==5) a-b
       else a*b
}
      suanfa
    }
    println(fun("hahahf")(5,3))
  }
}

三层嵌套

• 需求：输入一个数判断与3求余的关系，若等于零则输入两个数求和再判断和与4000的大小最后输入一个人名输出一句话，反之输入两个数求差判断与1000的大小再输入一个人名输出一句话。

object Test2 {
  def main(args: Array[String]): Unit = {
    def fun(num:Int):(Int,Int)=>String=>Unit={//嵌套其实就是输出的返回函数的箭头左边是内层函数的输入参数类型，右边是内存函数的输出参数类型
      if(num%3==0){
        def fun2(a:Int,b:Int):String=>Unit={//这里为什么是String？因为下一层函数输入的是人名
          if(a+b>4000){
            def fun3(s:String):Unit={
              println(s+"恭喜你收入多多")
            }
            fun3
          }else{
            def fun3(s:String):Unit={
              println(s+"还需多多努力呀")
            }
            fun3
          }
        }
        fun2
      }else{
        def fun2(a:Int,b:Int):String=>Unit={
          if(a-b>1000){
            def fun3(s:String):Unit={
              println(s+"你真是勤俭持家！！！")
            }
            fun3
          }else{
            def fun3(s:String):Unit={
              println(s+"要省着点用哦")
            }
            fun3
          }
        }
        fun2
      }
    }
   fun(2)(5000,3000)("马甲")
//简便：
object Test2 {
  def main(args: Array[String]): Unit = {
    def fun1(num: Int): (Int, Int) => String => Unit = {
      def fun2(a: Int, b: Int): String => Unit = {
        def fun3(str: String): Unit = {
        if (num % 3 == 0) {
            if (a + b > 3000) println(str + "大于3000")
            else println(str + "小于3000")
          }
        else {
            if (a - b > 1000) println(str + "大于1000")
            else println(str + "小于1000")
          }
        }
        fun3
      }
      fun2
    }
    fun1(6)(5000,3000)("zhu")
  }
}

形参是函数，返回是函数

• **需求：**输入参数是函数和String值，判断这个值与3求余的关系并输出一个加减函数

object Test3 {
  def main(args: Array[String]): Unit = {
def fun(f:String=>Int,str:String):(Int,Int)=>Int={
  val num=f(str)
  if(num%3==0){
    def fun1(a:Int,b:Int):Int={
      a+b
    }
    fun1
  }else{
    _-_
  }
}
    println(fun((x:String)=>{
      if(x.length>5) 6
      else 1
    }
      ,"hahah")(3,3))
  }
}

函数柯里化

• 柯里化是指这样一个函数，他接收函数A作为参数，运行后能够返回一个新的函数。并且这个新的函数能够处理函数A的剩余参数。

object Test4 {
  def main(args: Array[String]): Unit = {
    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
    }
    def fun3(a:Int)(b:Int)(c:Int)(d:Int):Int={
      a+b+c+d
    }
    def fun4(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))
    println(fun3(1)(2)(3)(4))
  }
}

模式匹配

• 需求：输入一个数字转成对应英文和判断输入的类型

object demoMatch {
  //java类方法
  def method1(x:Int):String={
    if(x==1) "one"
    else if(x==2) "two"
    else  "many"
  }
  //模式匹配
  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("输入的值为"+x)
    case x:Int=>println("输入的值为Int类型，值为："+x)
    case x:String=>println("输入的值为String类型，值为："+x)
    case x:Double=>println("输入的值为Double类型，值为："+x)
    case _=>println("我也不知道是啥")
  }

  def main(args: Array[String]): Unit = {
    println(method1(3))
    println(match1(4))
    match2('a')
  }
}

样例类

• 定义样例类需要放在main方法外甚至object单例对象外，不要放在main方法里。因为样例类需要放在方法的作用域之外(即Java的成员变量位置之外)。def main(args:Array[String]):Unit里面就是其方法的作用域。

• 首先需要case class 定义一个对象，含有属性和类型。

• 然后输入参数类型即为这个对象，本身就是一个类

• 然后运用模式匹配解决问题

• 对于样例类，只要值相同就是同一个对象，所以==和.equals是一样的

• Scala中在class关键字前加上case关键字 这个类就成为了样例类，样例类和普通类区别：

  • 不需要new可以直接生成对象
  • 默认实现序列化接口
  • 默认自动覆盖 toString()、equals()、hashCode()

object demoCaseClass {
  case class Student(name: String, age: Int)
  def match1(studnet: Student): Unit = studnet match {
    case Student("Zhu", 22) => println("Hello," + studnet.name)
    case Student("Tang", 21) => println("Welcome," + studnet.name)
    case stu: Student => println("您的名字为：" + stu.name)
  }
  def main(args: Array[String]): Unit = {
   val stu1=Student("zhu",22)
    match1(stu1)
    
    val stu2=Student("Zhu",22)
    if(stu1.equals(stu2)) println("是同一个学生")
    else println("不是哦")
    if(stu1==stu2) println("真的是一个人")
    else println("要我怎么说你才信他们是双胞胎")
  }
}

隐式参数

• 隐式参数需要定义在object内，不能定义在纯类中。
• 且同一个类型只能有一个
• 隐式参数只能放在最后
• 一个函数存在多个隐式函数的话，把它们放在一起，前面只有一个implicit
• 优先级：传参 >隐式参数 >默认
• 给隐式参数一个默认值目的是为了防止调用时既没有传参也没有定义隐式参数或失效而引起的找不到值的错误。

object demoImplicit {
  def main(args: Array[String]): Unit = {

    def fun1(a:Int,b:Int)(c:Int):Int={ //柯里化函数
    a+b+c
    }
    //隐式参数需要定义在object内，不能定义在纯类中。
    implicit var a:Int=10 //同一个类型只能有一个
    implicit var str:String="hello"
    def fun2(a:Int,b:Int)(implicit c:Int=5):Int={//给隐式参数一个默认值目的是为了防止调用时既没有传参也没有定义隐式参数或失效而引起的找不到值的错误。
      a+b+c
    }

    def fun3(a:Int,b:Int)(implicit c:Int=5,str:String):Int={//一个函数存在多个隐式函数的话，把它们放在一起，前面只有一个implicit
      println(str)
      a+b+c
    }
    println("fun3结果为："+fun3(30,20))//hello
                                       // 60
    println("fun3结果为："+fun3(30,30)(20,"heheda"))//heheda
                                                   //  80

    println("fun1结果"+fun1(10,10)(20)) //40
    //优先级：传参 >隐式参数 >默认
    println("fun2结果"+fun2(10,10)(20))//40,优先级最高
    println("fun2接果"+fun2(10,10)())//25,有括号就代表已经显示传参，就屏蔽了隐式参数，不过传了个空那只能调用默认值5。这个时候如果连默认值5都没写就会编译报错。
    println("fun2结果"+fun2(10,10))//30,隐式参数第二，注掉隐式参数后，默认值才起效果

  }
}