scala高阶函数---闭包-控制抽象-尾递归-while-惰性函数

package scala01

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

//    TODO 闭包概念
//    需求：两数之和
    def sumXY(x:Int)={
  def sumY(y: Int): Int = {
    x + y
  }
  sumY _
}
//    TODO 闭包应用场景（高阶函数第三种用法）

//    什么情况下出现闭包--》函数嵌套使用的时候 ---》高阶函数的第三种用法


    //    需求--任意两数求和
//    优势   通用性强  适用性差
    def sumAB(a: Int, b: Int): Int = {
      a + b
    }

    println(sumAB(10, 10))
//    需求  任意一个数和100求和

    sumAB(100,10)
    def sumBy100(x:Int) ={
      def sumY(y:Int):Int={
        x+y
      }
      sumY _

    }

    val intToInt: Int => Int = sumBy100(100)
    println(intToInt(20))










  }

}

package scala01

object scala09_Recursion {

  def main(args: Array[String]): Unit = {
//    递归

//    求阶乘 --5
//    使用循环来实现
    val n = 5
    var res=1
    for(i<-1 to n){
      res*=i
    }
    println(res)

//    递归来实现
    def func(n1:Int):Int={
      if (n1<=1){
        1
      }else {
        func(n1 - 1) * n1
      }
    }

    println(func(5))


//    存在问题  函数嵌套使用   就会存在内部函数使用外部函数的变量  就会造成压寨


//    解决方案  使用尾递归

    def func1(n1:Int,res:Int=1):Int={
      if (n1==1){
        res
      }else{
        func1(n1-1,res*n1)
      }
    }




  }

}

package scala01

object scala10_ControlABs {
  def main(args: Array[String]): Unit = {
    //    控制抽象
    //    定义一个函数
    def sayHI(name: String): String = {
      println("sayhi被调用了")
      println(name)
      s"hi $name"
    }

//    值调用，传递的参数列表也是代码块只调用的试用下  代码块一定会先执行
    val name: String = sayHI({
      println("我是代码块")
      "zhangsan"
    })
    println(name)


    def sayHI1(name: =>String): String = {
      println("sayhi被调用了")
      println(name)
      s"hi $name"
    }

    val name1: String = sayHI1({
      println("我是代码块")
      "list"

    })

    println(name1)


  }



}

package scala01

object scala11_Mywhile {
  def main(args: Array[String]): Unit = {
    var i=0
    while(i<5){
      println(i)
      i+=1

      def myWhile(bool: =>Boolean)(op: =>Unit):Unit={
        if (bool){
          op
          myWhile(bool)(op)
        }
      }

//      调用
      var j =0
      myWhile({
        println("我是代码块...")
        j<5
      })({
        println(j)
        j+=1
      })







    }
  }

}

package scala01

object scala12_lazyFunc {
  def main(args: Array[String]): Unit = {
//    惰性函数 懒加载
//    定义一个函数
    def sumAB(a:Int,b:Int):Int={
  println("sumAB start....")
  a+b
}

    lazy val i: Int = sumAB(1, 2)
    println("=============================")
    println(i)
//    合理利用资源  提升性能  业务决定  提升用户体验






  }

}