Scala函数式编程（一）

基本语法

[修饰符] def 函数名 (参数列表) : [:返回值类型] = {
函数体
}
private def test ( s : String ) : Unit = {
println (s)
}

函数与方法的区别

scala方法是类的一部分，函数是一个对象，可以赋值给一个变量。即在类中定义商务函数都是方法。scala与java类似，方法是组成类的一部分，scala中的函数则是一个完整的对象。声明在类中的函数称之为方法，所以类中的函数就应该符合方法的约束：重写和重载。函数没有重写和重载的概念。
方法就是函数，函数可以声明在任意地方：函数中可以声明函数，方法中也可以声明函数。
函数中无法声明方法，方法中也不能声明方法，函数有作用域，只能在当前的作用域中使用。
方法也有作用域，在当前类中可以任意使用，在类的外部可以访问权限，对象的调用来访问。

函数的定义

package com.atguigu.chapter03

object Scala2 {
  def main(args: Array[String]): Unit = {
    //Scala是一个完全的函数式语言，万物皆函数
    //函数式scala语言中非常重要的一个语法结构
    //1.函数式编程重要的是函数的名字，输入的参数和输出的结果

    //TODO Function -函数声明和使用

    //TODO 1.无参，无返回值
    def fun1():Unit={
      println("fun1...")
    }
    //函数的调用
    //函数名（参数）
    fun1()
    //如果函数声明时没有参数，调用时小括号可以省略
    fun1

    //TODO 2.无参，有返回值
    def fun2():String  ={
      return "zhangsan"
    }

    println(fun2())
    val s=fun2()
    println(s)

    //TODO 3.有参，无返回值
    //参数的声明方式=>参数名：参数类型，此时参数类型不能省略
    def fun3(name:String): Unit ={
      println("Name="+name)
    }
    fun3("zahngsan")//如果函数声明了参数，调用时必须传递参数
    //方法的参数传递是：值传递
    //值传递：方法参数传递，传递的就是参数的值，基本数据类型，值是多少那么传的就是多少
    // 如果参数为引用类型，传递的依然是值，这里的值其实是引用类型数据的内存地址


    //TODO 4.有参，有返回值
    def fun4(name:String): String ={
      return "Name="+name
    }
    val s1=fun4("zahngsan")
    println(s1)

    //TODO 5.多参，无返回值
    //多个参数之间用逗号分割
    def fun5(name:String,age: Int): Unit ={
      println(s"Name=${name},Age=${age}")
    }
    fun5("zhangsan",20)
    //如果函数声明中有多个参数 那么调用时参数数量匹配，且按照声明顺序进行赋值和匹配

    //TODO 6.多参，有返回值
    def fun6(name:String,age:Int): String ={
      return "Name="+name+"Age="+age
    }
    //参数不能多传
    val s2 =fun6("zhangsan",20)
    println(s2)

    //TODO 7.函数参数的个数 (没有约束)
    def fun7(
          //25个参数....

            ): Unit ={
      println("fun7")
    }
    fun7()


  }

}

函数的参数

package com.atguigu.chapter03

object Scala3 {
  def main(args: Array[String]): Unit = {
    //TODO 动态参数 -可变参数
    //参数可以根据传值自动发生变化
    //需要将参数声明时，类型后面增加特殊符号:* 这里的星号表示多（动态）
    //传值的时候可以传递一个参数或多个参数甚至不传
    //所谓的动态参数，其实就是参数的类型集合
    def fun1(name:String*): Unit ={
      println(name)
    }
//    val s ="zahngsan" * 2
//    println(s)
    fun1("zhangsan")
    fun1("zhangsan","lisi","hauhua")

     //如果参数列表中含有可变参数，那么这个可变参数应该放置在列表的最后声明
    //一个函数不允许声明多个可变参数的
    def fun11(age:Int,name:Any*): Unit ={

    }
    fun11(20,"zhangsan",10)

    //TODO 参数的默认值
    //默认情况下，函数的参数是使用val声明的，所以不能修改
    //为了解决参数不能修改的问题，scala提供了一个参数默认值得语法，声明参数的时候直接提供默认值
    //声明参数的时候，同时提供默认值，那么在调用函数时，如果函数不传递参数，那么就自动使用默认值
    def fun2(password:String="000000"): Unit ={
//      if(password==null || password==""){
//        password="000000"
      println(password)
      }
    fun2("123123")//没传就用0000000.传了就用123123
    fun2()

    //TODO 带名参数
    def fun3(password:String="000000",loginacct:String): Unit ={
      println("Acc:"+loginacct +"Pswd:"+ password)
    }
    //如果想要改变传值的顺序，需要采用特殊的语法操作：带名参数
    //在函数调用传值的时候，把参数的名称带上
    fun3(loginacct = "zhangsan")
    }
}

函数至简原则

package com.atguigu.chapter03

object Scala4 {
  def main(args: Array[String]): Unit = {
    //TODO 函数式编程 至简原则
    //scala函数式编程中有一个重要的原则：至简原则
    //这里的简表示简单，函数式编程能省则省
    def test(): String = {
      return "zahngsan"
    }

    //val s=test()
    val s = test
    println(s)

    //1.函数明确有返回值，那么函数体中的return关键字可以省略
    // 满足条件的最后一行代码执行结果为表达式的返回值
    def test1(): String = {
      "zhangsan"
    }

    //2.如果能够通过返回值推断出函数的返回值类型，那么返回值类型可以省略
    //以后写函数时 尽量不要写返回值类型，最好由编译器自动推断
    //多态的时候不能省略
    def test2() = {
      val age = 30
      if (age < 16) {
        16
      } else {
        println()
      }
    }

    //3.如果参数列表中没有参数，声明时小括号可以省略
    def test3: Unit = {
      println("zhangsan")
    }
    //test3() 如果函数没有声明参数列表，那么调用函数时，为了统一也不能增加参数列表的小括号
    test3

    //4.如果函数的逻辑代码只有一行，那么大括号可以省略
    def test4(): Unit = println("zhangsan")

    test4()

    //融合以上四种简化情况
    //    def test5(): String ={
    //      return "zhangsan"
    //    }

    //    def test5(): String ={
    //      "zhangsan"
    //    }

    //    def test5()={
    //      "zhangsan"
    //    }

    //    def test5={
    //      "zhangsan"
    //    }

    //scala中函数和变量必须通过关键字来区分
    def test5 = "zhangsan"

    val test55 = "lisi"

    println(test5)
    println(test55)

    //6.将unit和等号同时省略，函数没有返回值
    //如果一个函数明确没有返回值，那么函数体中有return不起作用
    //如果省略返回值类型，那么函数体中有return会发生错误
    //希望unit返回值类型可以省略，而且同时函数体中也不用返回结果，这时可以将unit和等号同时省略
    //在这种场景下，return仅仅起到了改变了流程的作用

//    def test6(): Unit = {
//      return "zhangsan"
//    }

    def test6() {
      return "zhangsan"
    }
    println(test6())

    //7.函数的名称和关键字也可以省略
    //当关键字和函数名省略后，返回值类型也应该同时省略
    //需要将等号改为颜文字：=>
     //如果函数声明时没有名字和关键字，称为匿名函数
    //test(x:Int, y:Int) => x+y
    //multi(x:Int, y:Int) => x*y
//    def test7(): Unit ={
//      println("test7...")
//    }
//    test7()

    () => {
      println("test7...")
    }
    //大括号可以理解为代码块
    //小括号表示unit，没有值
      //匿名函数不能直接调用，需要将函数赋值给变量使用

      val f=() =>{
        println("test7...")
      }
      //此时变量就是一个函数，所以变量就可以调用了
      f()

  }
}