07 详解scala函数编程

1 详解scala函数编程

1-1 函数编程简述

• 面向对象，解决问题时，将问题拆解成一个一个小问题（形成的对象），分别解决。
• 函数式编程关心是的问题的解决的方案（封装功能），重点在于函数（功能）函数的入参，出参
• 函数和java中的method java中的method依赖于某个对象 函数就可以独立声明 他们的一直点 都是对功能的封装
• scala的语法十分灵活，在任意语法中可以声明其他语法规则

在main函数体外面的源码

 def test(str: String): Unit = {
    //函数提
    println(str)
  }

  def main(args: Array[String]): Unit = {
    test("张三");
  }
  

在main函数体里面的源码

  def main(args: Array[String]): Unit = {
	 def test(str: String): Unit = {
	    //函数提
	    println(str)
	  }
    test("张三");
  }
  

1-2 函数的入参(方法参数)和出参（返回值）

1-2-1 无参 无返回值

def test(): Unit ={
    println("Test")
  }

1-2-2 有参 无返回值

 def test1(s:String): Unit ={
    println(s)
  }

1-2-3 有参 有返回值

def test2(s:String): String ={
    return  s+"......."
  }

1-2-4 无参 有返回值

def test3(): String ={
    return  "张三......."
  }

1-3 scala自动推断功能简述

• scala可以采用自动推断功能来简化函数的声明
  源码

def test(): Unit ={
    return "张三"
  }

• 如果将函数体的最后一行代码进行返回，那么return关键字就时可以省略的

源码

def test2(): String ={
    "张三"
  }

• 如果可以根据函数的最后一行代码进行推断类型，那么函数返回值类型可以省略
  源码

def test3() ={
    "张三"
  }

• 如果函数体中只有一行代码，大括号可以省略
  源码

def test4() = "张三"

• 函数声明中没有参数列表，小括号可以省略
• 声明函数必须要增加def关键字
• 注意区变量和函数
  源码

  def test5 = "张三"
  val test6 = "张三"

• 如果明确函数没有返回值 那么等号可以省略，省略后，编译器不会将函数体最后一行代码最为返回值

def test7(){
    "张三"
  }

• 如果函数没有参数列表，可以省略小括号，调用一定不能使用小括号
• 如果函数没有参数列表，但是没有省略小括号，调用时可加可不加
  匿名函数

 ()->println("xxxx")

1-4 可变函数

• 调用函数时，可以传多个参数，也可以不参参数

 def  test(name:String*): Unit ={
      println(name)
    }
    //test("张三","李四")
    test()

• 在底层中scala根据不同的参数返回对应的返回值

1-5 默认参数

• 如果希望函数中的某一个函数使用默认值，那么可以声明时直接赋初始值

 def test(name: String , age: Int = 20): Unit ={
      println(s"${name} - ${age}")
    }
    test("张三",11)
    test("张三")

• 调用函数时，参数匹配规则从前到后，从左到右

def test2(name2 :String = "lishi",name1: String ): Unit ={
      println(s"${name2} - ${name1}")
    }

• 带名参数 用于指定具体的参数

 test2(name1="zhangsan");

1-6 函数的传递

• scala 时完全面向函数式编程语言
• 函数可以赋值给变量
• 函数可以作为函数的参数
• 函数可以作为函数的返回值

1-6-1 函数作为返回值

 def main(args: Array[String]): Unit = {
      
        def f(): Unit = {
          println("Fuction")
        }
        def f0()= {
          // 返回函数
          // 直接返回函数，有问题,需要郑家特殊符号：下划线
          f _
        }
        f0()()
       }

• 上面将 f() 这个函数作为了返回值
• f0()() 函数调用的过程 第一个()是调用了f0() 这个函数，第二个()是调用返回是f()函数
  -一个函数，加上()就执行返回对应函数

   def f1(i: Int) ={
          def f2(j: Int) ={
            i*j
          }
          f2 _
        }

        val num: Int = f1(2)(3)
        println(num)

• 这种事有参数情况

1-6-2 函数柯里化

• 函数柯里化 对返回函数的函数的简化

def f3(i: Int)(j: Int): Int = {
         i * j
     }
     println(f3(2)(3))

1-6-3 闭包

-闭包的理解还是需要下面这个段代码

   def f1(i: Int) ={
          def f2(j: Int) ={
            i*j
          }
          f2 _
        }

        val num: Int = f1(2)(3)
        println(num)

• 一个函数在实现逻辑时，将外部的变量引入到函数的内容，改变了这个变量的声明周期，称之为闭包

使用匿名函数改善代码

• 将函数作为参数传递给另外一个函数，需要采用特殊的声明方式
• 参数列表=> 返回值类型

    def f6(f:()=>Unit): Unit ={
      f()
    }
    f6(()=>{println("xxxxx")})