Scala--函数式编程概念

函数式编程

        解决问题时，将问题分解成一个一个的步骤，将每个步骤进行封装（函数），通过调用 这些封装好的步骤，解决问题。

        Scala 语言是一个完全函数式编程语言。万物皆函数。 函数的本质：函数可以当做一个值进行传递

函数基本结构

 函数与方法的区别

1. 为完成某一功能的程序语句的集合，称为函数。
2. 类中的函数称之方法。

object fun {
  def main(args: Array[String]): Unit = {
    //定义函数
    def sayHi(name:String): Unit ={
      println(name)
    }

    //调用函数方法
    sayHi("AA")
    //调用对象方法
    fun.sayhi("BB")
  }
  //定义对象的方法
  def sayhi(name:String): Unit ={
    println(name)
  }
}

• Scala 语言可以在任何的语法结构中声明任何的语法
• 函数没有重载和重写的概念；方法可以进行重载和重写
• Scala 中函数可以嵌套定义

函数定义 

object fun {
  def main(args: Array[String]): Unit = {
    //函数 1：无参，无返回值
    def fun1(): Unit = {
      println("无参，无返回值")
    }
    //函数调用
    fun1()

    //函数 2：无参，有返回值
    def fun2(): Int = {
      println("无参，有返回值")
      return 1
    }

    //函数 3：有参，无返回值
    def fun3(name : String): Unit = {
      println("有参，无返回值"+name)
    }

    //函数 4：有参，有返回值
    def fun4(name : String): String = {
      println("有参，有返回值"+name)
      return name
    }

    //函数 5：多参，无返回值
    def fun5(name1 : String,name2 : String): Unit = {
      println("多参，无返回值"+name1+name2)
    }

    //函数 6：多参，有返回值
    def fun6(a : Int,b : Int): Int = {
      println(a+b)
      return a * b
    }
    println(fun6(3, 2))
  }
}

函数参数  

object fun {
  def main(args: Array[String]): Unit = {
//    （1）可变参数
    def fun1(str:String*): Unit = {
      println(str)
    }

//    （2）如果参数列表中存在多个参数，那么可变参数一般放置在最后
    def fun2(str1 : String,str2 : String*): Unit = {
      println(str1+str2)
    }

//    （3）参数默认值，一般将有默认值的参数放置在参数列表的后面
    def fun3(name:String = "默认值"): Unit = {
      println(name)
    }

//    （4）带名参数
    def fun4(name : String,age : Int): Unit = {
      println(s"${age}---${name}")
    }

    fun4(name = "dd",age = 1)
  }
}

函数至简原则

object fun {
  def main(args: Array[String]): Unit = {
//    （1）return 可以省略，Scala 会使用函数体的最后一行代码作为返回值
    def fun1(name : String): String = {
      name
    }
//    （2）如果函数体只有一行代码，可以省略花括号
    def fun2(name : String): String = name

//    （3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）
    def fun3(name : String) = name

//    （4）如果有 return，则不能省略返回值类型，必须指定
    def fun4(name: String) = {
      name
    }

//    （5）如果函数明确声明 unit，那么即使函数体中使用 return 关键字也不起作用
    def fun5(name : String): Unit = {
      return name
    }
//    （6）Scala 如果期望是无返回值类型，可以省略等号
    def fun6(name : String){
      println(123)
    }

//    （7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加
    def fun7(): Unit = {
      println("调用我可以不加括号")
    }
    fun7

//    （8）如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略
    def fun8:Unit = {
      println("666")
    }
    fun8
//    （9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略(匿名函数)
    (name : String) =>{
      println("匿名函数体")
    }

  }
}