Scala基本函数式编程

1.1基本语法

def 函数名(参数1:参数类型1,参数2:参数类型2):函数返回值类型 = {
函数体
}
eg:
    def fun():Unit = {
      println("function ...")
    }

1.2函数&方法

函数:简单理解方法就是函数，只不过类中声明的函数称之为方法，其他场合声明的就是函数了。函数可以嵌套使用，函数的作用域比较窄，函数没有重载和重写的方法

方法:方法可以重载,重写方法不可嵌套使用.在方法内再写方法就不是方法 在Scala02_Function_Method中调不到方法的,方法的作用域 比较大

1.3函数的定义

1.3.1无参 无返回值

 def fun1(): Unit = {
      println("fun1.... 无参 无返回值")
    }

    //如果函数声明时候无参 调用时 可以省略小括号
    //fun1()        
    fun1

1.3.1无参 有返回值

def fun2(): String = {
      return "zhangsan 无参 有返回值"
    }

    val result: String = fun2()
    println(result)

1.3.1有参 有返回值

参数的声明方式 参数名:参数方式 多个用逗号隔开

 def fun3(name:String): Unit = {
      println(name +"  有参 无返回值")
    }
    //函数的参数 只有一个 也不能省略小括号
    fun3(" lisi ")

1.3.1有参 有返回值

    def fun4(name:String): String = {
      return name + "  有参 有返回值"
    }
    val result: String = fun4("zhaosi")
    println(result)

1.3.1多参 无返回值

函数存在多个参数时应该匹配它的个数和类型,匹配参数时,按照顺序进行匹配,java中方法参数的传递都是值传递

  def fun5(name:String,age : Int): Unit = {
      println(name +" "+ age + " 多参 无返回值 ")
    }
    fun5("wangwu",23)

1.3.1多参 有返回值

def fun6(name:String,age : Int): String = {
      return name +" "+ age + " 多参 有返回值 ";
    }
    val result: String = fun6("zhaoliu",18)
    println(result)

1.4函数的参数

1.4.1 可变参数

参数的个数 在某些情况下 不固定

使用可变参数 : 参数的类型 后面增减星号（*）

可变参数在使用时都是集合对象 WrappedArray

 def fun2(name :String*): Unit = {
      println("fun2 ...  " + name)
    }

    fun2()  //表示没有参数  fun2 ...List()
    fun2("zhang")  //表示一个参数  fun2 ...WrappedArray(zhang)
    fun2("zhangsan","lisi","wangwu")  //表示有三个参数  fun2 ...WrappedArray(zhangsan, lisi, wangwu)

可变参数 和JAVA中（...）传入多个参数 一样 有其他参数需要放到前面 可变参数 放到最后,一个函数 不能有多个可变参数 有且只能有一个

    def fun22(email:String,name:String*): Unit = {
      println("fun22 .... "+email + "  " +  name)
    }
    fun22("2201231@163.com","zhandsan","lisi") //fun22 .... 2201231@163.com  WrappedArray(zhandsan, lisi)

1.4.2 参数默认值

底层 就是编译为了一个方法 但不传参数时候 由编译器自动调用这个方法,函数的参数 默认 以 val声明 不可变

 def fun3(password:String = "123456" ): Unit = {
      println(password)
    }
    //调用时 参数如果想使用默认值 可以不传入参数
    fun3()  //123456
    //调用时 如果不想使用默认值 直接传参即可
    fun3("admin") //    admin

1.4.3 带名参数

 def fun4(password:String="123123",name:String): Unit = {
      println(password  +"  "+ name)
    }

    //参数在传递时候 默认为顺序匹配
    //Scala 可以通过特殊的语法改变传值的顺序

    fun4(name="zhangsan")

在一个函数中参数的默认值和可变参数最多只能存在一个，两个不能同时存在同一个函数中

1.5 Scala至简原则

所谓的至简原则，其实就是Scala的作者为了开发人员能够大幅度提高开发效率。通过编译器的动态判定功能，帮助我们将函数声明中能简化的地方全部都进行了简化。也就是说将函数声明中那些能省的地方全部都省掉。所以这里的至简原则，简单来说就是：能省则省

1. return 关键字 可以省略

函数体会将满足条件的最后一行的代码的执行结果作为函数的返回值

    def test1(): String = {
        "lisi"
    }
 println(test1())

2.如果函数返回数据 可以推断返回值类型的话，返回值类型可以省略

    def test2() = {
      "wangwu"
    }
    println(test2())

3.如果函数体的逻辑代码只有一行的话 那么花括号 可以省略

  def test3() = "wangwu"

4.如果函数的参数列表中 没有声明任何的参数 那么参数列表可以省略

 def test4 = "zhaoliu"

5.省略等号

1)如果函数体中有明确的return语句，那么返回值类型不能省略

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun5(): String = {
            return "zhangsan"
        }
        println(fun5())
    }
}

2)如果函数体返回值类型明确为Unit, 那么函数体中即使有return关键字也不起作用

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun5(): Unit = {
            return "zhangsan"
        }
        println(fun5())
    }
}

3)如果函数体返回值类型声明为Unit, 但是又想省略，那么此时就必须连同等号一起省略

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun5() {
            return "zhangsan"
        }
        println(fun5())
    }
}

6.省略名称和关键字

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        () => {
            println("zhangsan")
        }
    }
}