Scala之函数式编程函数和方法的区别： 参数默认值： 函数至简原则—能省则省：匿名函数的化简：高阶函数：匿名化简：柯里化写法：闭包：递归：优化递归：尾递归优化控制抽象：懒加载：

Posted on by hackdl

目录

函数和方法的区别：

 参数默认值：

 函数至简原则—能省则省：

至简原则细节

匿名函数的化简：

匿名函数至简原则：

高阶函数：

高阶函数的三种用法：

（1）函数可以作为值进行传递

（2）函数可以作为参数进行传递**

匿名化简：

柯里化写法：

闭包：

递归：

优化递归：尾递归优化

控制抽象：

值调用：

名调用：

懒加载：

函数和方法的区别：

方法和函数的区别就是在位置上的不同

方法–是在类中表示（面向对象）—–伴生对象中的方法（相当于静态方法）  或者在伴生类中定义方法

写在其他位置的都是函数

函数是支持嵌套的但是并不支持函数的重载和重写（重载和重写是针对的类中的方法而言）

Scala中也有可变参数，不过与Java不同  

def main(args: Array[String]): Unit = {
    def sayhi(name: String*): Unit={
      println(s"hi $name")
    }
    sayhi()
    sayhi("shdus")
    sayhi("sdsdsd","shdushd")
  }

执行结果

 参数默认值：

（Java中不存在默认值   可通过重载实现）

  def main(args: Array[String]): Unit = {
    def sayhi(name: String="zhangsan"): Unit={
      println(s"hi $name")
    }
    sayhi()
    sayhi("shdus")
    //sayhi("sdsdsd","shdushd")
  }

执行结果：

 当想使用默认参数时，且有多个参数时  需要使用带名参数

 def main(args: Array[String]): Unit = {
    def sayhi(name: String="zhangsan",age :Int): Unit={
      println(s"hi $name age is $age")
    }
    sayhi(age = 18)
    sayhi("shdus",18)
    //sayhi("sdsdsd","shdushd")
  }

执行结果：

 函数至简原则—能省则省：

至简原则细节

（
1
）
return
可以省略，
Scala
会使用函数体的最后一行代码作为返回值

                 特殊情况  return 不能省略：

    //
    def sayhi2(name :String) :String ={
      if(name==null)
        {
          return ""
        }
      println(s"Hi $name")
       name
    }

比如 传入参数为null  这个return 就不能省略  这里要作为程序的一个出口

如果省略 则会执行下边的语句   返回name

（
2
）如果函数体只有一行代码，可以省略花括号
                 如果不是一行代码而且省略了
（
3
）返回值类型如果能够推断出来，那么可以省略（和返回值类型一起省略）
                        //函数式编程最终省略的结果是 只保留传入的是什么  传出的是什么

（4）如果有 return，则不能省略返回值类型，必须指定

因为每一行代码都是一个代码块   如果不写返回类型 就会返回默认最后一行代码 这时return name的返回值类型为nothing类型

  def sayhi5(name :String):String={
      println(s"hi $name")
      return name
    }
                        
（
5
）
如果函数明确声明 unit，那么即使函数体中使用 return 关键字也不起作用
（6）Scala 如果期望是无返回值类型，可以省略等号
（7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加
（8）如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略
（
9
）如果不关心名称，只关心逻辑处理，那么函数名（
def
）可以省略—-匿名函数
（
=>前后分别是传入参数和返回值  =之前的是传入参数与返回值类型 = 之后 是传入的变量名 与实现逻辑）
（匿名函数中没有结果类型） 
    val function: (String, Int) => String = (name: String, age: Int) => name + "的年龄是" + age

匿名函数的化简：

匿名函数至简原则：

（1）参数的类型可以省略，会根据形参进行自动的推导 
可根据后边推到前面    也可根据前面推到后边  一般都是化简后边的
    val function1 = (name: String, age: Int) => name + "的年龄是" + age
    //后推前
    val function2: (String, Int) => String = (name,age) => name + "的年龄是" + age
//前面推后边
（2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参
数超过 1 的永远不能省略圆括号。
（3）匿名函数如果只有一行，则大括号也可以省略
多行不可以省略 

val function3: (String, Int) => String = (name: String, age: Int) =>
  {
    println(name + "的年龄是" + age+"666")
    name + "的年龄是" + age
  }
（4）如果（所有）参数（都）只出现一次，则参数省略且后面参数可以用_代替(但是只剩下_是避不可以的) 
    val function5 :(Int,Int)=>Int     //输入类型  输出类型
    = {
        2*_+4*_
      }

高阶函数：

高阶函数的三种用法：

（1）函数可以作为值进行传递

是将这个函数当作值进行传递   

val function: String => String = sayHi _
    function("tangxiaocong")

（2）函数可以作为参数进行传递**

先构造一个抽象函数   再调用的时候 当作参数传递真正的逻辑

 def operaXY(x:Int,y:Int,func:(Int,Int)=>Int):Int={
      func(x,y)
    }
    def sumXY(x:Int,y:Int): Int =x+y

    val i: Int = operaXY(10, 20, sumXY)
        println(i);

不化简的匿名：

    def operaXY(x:Int,y:Int,func:(Int,Int)=>Int):Int={
      func(x,y)
    }
    val i: Int = operaXY(10, 20, (x:Int,y:Int)=>x-y)
        println(i);

匿名化简：

    （1）化简类型

    （2）化简xy使用_代替

def operaXY(x:Int,y:Int,func:(Int,Int)=>Int):Int={
      func(x,y)
    }
    val i: Int = operaXY(10, 20, _-_)
        println(i);

（3）函数可以作为函数返回值返回***

涉及到函数的一个嵌套，一级调用返回的是一个函数  二级调用返回值

 def sumxy1(x:Int)={
      def sumy(y:Int): Int =
      {
        x+y
      }
      sumy _
    }

    val function1: Int => Int = sumxy1(10)
    println("歇一会")
    val i1: Int = function1(20)
    println(i1)

使用匿名函数进行化简

将等号后边的匿名函数作为返回值进行返回
 def sumxy2(x: Int): Int => Int = (y: Int) => x + y // 将等号后边的匿名函数作为返回值进行返回
    val intToInt: Int => Int = sumxy2(58)
    val i3: Int = intToInt(23)
    println(i3)

再次对匿名函数进行化简：
这种化简就是过度化简，难懂，不建议

 def sumxy3(x: Int): Int => Int = x + _

柯里化写法：

为了防止过度化简，作者引入了一个数学概念—柯里化的写法：
把多个形参的参数列表打散成一个形参的多个参数列表

 def KlH(c:Char)(s:String)(i:Int)={
      c !='0' || s != "" || i !=0
    }
    println(KlH('0')("")(0))

闭包：

闭包：函数式编程的标配

闭包
：如果一个函数，访问到了它的外部（局部）变量的值，那么这个函数和他所处的
环境，称为闭包(防止嵌套造成栈溢出)
闭包让代码更加灵活
（闭包其实就是把外层的变量打包成常量让内层函数使用） 
 def sumx(x:Int)={
      def sumy(y:Int):Int={
        x+y
      }
      sumy _
    }

上述采用的相当于是柯里化写法–先进行第一层调用  传入x再传递给内层函数  让x从变量变成常量，防止多次嵌套造成栈溢出

    val function: Int => Int = sumx(23)
    val i: Int = function(34)
    println(i)

递归：

递归：嵌套调用自身的函数
递归其实是不如循环快的，因为递归还是会造成压栈
  def jc(n: Int):Long ={
//递归：嵌套调用自身的函数
      if(n==1)
          1
      else
        jc(n-1)*n
    }
    println(jc(5))

优化递归：尾递归优化

尾递归：最后递归调用函数的一行 只有自身的函数  没有其他值

实际尾递归是用到了闭包  递归没办法用闭包（闭包   把上一层的变量在本层变成常量，减少压栈次数—-引入了res变量）

    def jc1(n: Int,res:Long=1):Long ={
      //递归：嵌套调用自身的函数
      if(n==1)
        res
      else
        jc1(n-1,res*n)
    }

判断是否是尾递归，可以使用一个注解—-@tailrec（不是尾递归会报错）

控制抽象：

函数定义有值调用和名调用（两种方式的传参方式不同）

值调用：

–将代码块的结果作为参数传入函数中，使用参数时，只带入结果

（值调用是指函数在调用时，先计算参数的值，然后再将这个值传递给函数。这意味着每个参数都只计算一次）

名调用：

–直接将整个代码块传入参数中，使用一次参数就会运行一次

（名调用是指函数在调用时，将参数的表达式作为代码块传递给函数。这意味着每次函数使用参数时都会重新计算它的值。）

  //值调用
    def sayHi1(name:String):Unit={
      println("函数调用")
      println(s"$name  hi")
      println(s"$name  hi")
    }
    sayHi1({
      println("hello")
      "linhai"
    })
    println("==================================================")
    //名调用
     def sayHi2(name: => String):Unit={
    println("函数调用")
      println(s"$name  hi")
      println(s"$name  hi")
    }
sayHi2({
  println("hello")
  "linhai"
})

运行结果的对比：

懒加载：

其实懒加载相当于Linux中的sleep函数   会暂时性休息，当使用到惰性语句的时候才会运行

关键字—lazy   而且lazy只能用于val关键字上

def sumxy(x:Int,y:Int):Int={
  println("sumxy调用")
  x+y
}
    lazy val sum=sumxy(10,20)
    println("啦啊啦啦啦")
    println(sum)

运行结果：

自定义while循环:

def mywhile(b:Boolean)(op : => Unit):Unit={
  if (b)
    {
      op
      mywhile(b)(op)
    }

}
var i=0
  mywhile(i

上述代码会陷入死循环   因为传入b(i

改进   对b进行名调用  

服务器托管，北京服务器托管，服务器租用，机房机柜带宽租用

服务器托管

咨询：董先生

电话13051898268 QQ/微信93663045！

上一篇:
下一篇: