scala (3) Function 和 Method

scala 定義函數的關鍵字是 val  

定義函數的通用格式是  val  函數名 = （參數清單）=> {函數體}

object FunctionDemo {

  //通用的定義格式
  val f1 = (x: Int, y: Int) => {
    x + y
  }

  //先定義函數的參數清單類型，具體的函數參數在函數體中定義
  val f2: (Int, Int, Int) => Int = {
    (x, y, z) => {
      x + y + z
    }
  }

  def main(args: Array[String]): Unit = {
    val v1 = f1(1, 2)
    println(v1)

    val v2 = f2(1, 2, 4)
    println(v2)

  }

}      

在scala 中定義方法的關鍵字是 : def 

定義方法的通用格式： def  方法名（參數清單) : 方法的傳回值類型 = {方法體}

//方法的傳回值不需要使用return關鍵字，同時方法的最後一條語句的傳回值作為整個方法的傳回值

//[注意]：如果一個方法有傳回值，那麼方法的最後一條語句的傳回值，一定要和方法的傳回值類型儲存一緻

def m1(x: Int, y: Int): Int = {

　　var a = 1

　　a += 2

　　x + y

}

//可以省略掉方法的傳回值類型,scala會自動根據最後一條語句的傳回值推斷出方法的傳回值類型
  def m2(x: Int, y: Int) = {
    x + y
  }      

//如果方法沒有傳回值，可以使用Unit來标注,變現為“()”，類似于java中的void
  def m3(x: Int, y: Int): Unit = {
    x + y
  }      

//也是沒有傳回值的方法，在參數清單括号後面直接添加方法體{}，我們稱這種方法為過程
  def m3_3(x: Int, y: Int) {
    println(x + y)
  }      

//先定義方法參數清單類型，具體的參數名稱在方法體中
  def m4: (Int, Int, Int) => Int = {
    (x, y, z) => {
      x + y + z
    }
  }      

//柯理化
  def m5(x: Int)(y: Int) = {
    x + y
  }

  //柯理化
  def m6(x: Int) = (y: Int) => {
    x + y
  }      

//如果定義一個方法，方法名稱後面的參數清單為空，那麼在調用的時候可以加括号，也可以不叫括号
  def m7() = {
    println("hello world")
  }

  //如果定義一個方法，方法沒有參數清單，那麼在調用的時候也不能加“()”,否則編譯不通過
  def m8 = {
    println("hello world")
  }      

//遞歸方法要求我們必須寫明方法的傳回值類型，不能省略掉否則報錯
  def m9(num: Int): Int = {
    if (num <= 0) 0 else m9(num - 1)
  }

  //當參數個數不固定時，那麼這時候可以将參數定義為可變參數，可變參數要求是方法的最後一個參數
  def m10(name: String, nums: Int*): Unit = {
    var sum = 0
    for (num <- nums) {
      sum += num
    }
    println(name + "=" + sum)
  }      

//在Scala中，有時我們調用某些方法時，不希望給出參數的具體值，而希望使用參數自身預設的值，
  // 此時就定義方法時使用預設參數
  //在調用方法的時候，指派是從左往右依次指派，是以說需要把沒有預設值的放在最前面
  def m11(age: Int, name: String = "旺财", sex: String = "男") = {
    println(name + "=" + age + "=" + sex)
  }      

def main(args: Array[String]): Unit = {
    /*   val sum = m1(1, 2)
       println(sum)
   */
    /*    val sum = m2(1, 3)
        println(sum)*/

    // println(m3(1, 2))

    //println(m5(2)(3))
    //    println(m6(3)(4))
    //m7
    // m8
    // m3_3(1, 3)
    // println(m9(9))
    // m10("旺财", 1, 2, 3, 4, 5)

    // m11(12)
    //帶參數名調用,傳入參數就可以無序
    m11(sex = "公", age = 12,name = "zs")

  }

}      

在scala中方法可以轉換成函數，有兩種轉換方法

第一種：下劃線  ：方法名

第二種：scala會隐式的去轉換，不需要手動實作

object MethodToFunctionDemo {

  def m1(x: Int, y: Int) = {
    x + y
  }
  /**
    * 接收三個參數
    *
    * @param f 它是一個函數，接收兩個參數，傳回值是Int類型，在傳入這個參數的時，傳入進來的參數必須符合函數的簽名
    * @param y 普通參數
    * @param x 普通參數
    * @return
    */

  def m2(f: (Int, Int) => Int, y: Int, x: Int) = {
    f(x, y)
  }
  def main(args: Array[String]): Unit = {
    //通過下劃線将方法轉換成函數
    // val f1 = m1 _
    // println(f1)

    //scala會自動進行轉換
    //val v2 = m2(m1, 1, 2)
    // println(v2)

    val arr = Array(1, 2, 3, 4, 5)

    val foreachFunchion = (x: Int) => {
      println(x)
    }

    // arr.foreach(foreachFunchion)

    //arr.foreach((x: Int) => {println(x) })

    //arr.foreach((x: Int) => println(x))
    // arr.foreach((x) => println(x))
    // arr.foreach(println(_))

    val filterFunction = (x: Int) => {
       x > 3
    }
    arr.filter(filterFunction).foreach((x:Int)=>println(x))
  }
}      

轉載于:https://www.cnblogs.com/mlfh1234/p/9222233.html