Scala方法定义，方法和函数的区别，将方法转换成函数

1． 定义方法和函数

1.1． 定义方法

方法的返回值类型可以不写，编译器可以自动推断出来，但是对于递归函数，必须指定返回类型

1.2． 定义函数

1.３．方法和函数的区别

在函数式编程语言中，函数是“头等公民”，它可以像任何其他数据类型一样被传递和操作
案例：首先定义一个方法，再定义一个函数，然后将函数传递到方法里面

package cn.toto.scala

/**
  * Created by toto on 2017/6/27.
  */
object MethodAndFunctionDemo {
  //定义一个方法
  //方法m2参数要求是一个函数，函数的参数必须是两个Int类型
  //返回值类型也是Int类型
  def m1(f:(Int,Int) => Int) : Int = {
    f(2,6)
  }

  //定义一个函数f1,参数是两个Int类型，返回值是一个Int类型
  val f1 = (x:Int,y:Int) => x + y
  //再定义一个函数f2
  val f2 = (m:Int,n:Int) => m * n

  //main方法
  def main(args: Array[String]): Unit = {
    //调用m1方法，并传入f1函数
    val r1 = m1(f1)

    println(r1)

    //调用m1方法，并传入f2函数
    val r2 = m1(f2)
    println(r2)
  }
}

运行结果：

8
12

1.2． 将方法转换成函数（神奇的下划线）

代码如下：

package cn.toto.scala

/**
  * Created by toto on 2017/6/27.
  */
object TestMap {

  def ttt(f:Int => Int):Unit = {
    val r = f(10)
    println(r)
  }

  val f0 = (x : Int) => x * x

  //定义了一个方法
  def m0(x:Int) : Int = {
    //传递进来的参数乘以10
    x * 10
  }

  //将方法转换成函数，利用了神奇的下滑线
  val f1 = m0 _

  def main(args: Array[String]): Unit = {
    ttt(f0)

    //通过m0 _将方法转化成函数
    ttt(m0 _);

    //如果直接传递的是方法名称，scala相当于是把方法转成了函数
    ttt(m0)

    //通过x => m0(x)的方式将方法转化成函数,这个函数是一个匿名函数，等价：(x:Int) => m0(x)
    ttt(x => m0(x))
  }
}

 -------------------------

package com.cx.spark.demo

object MethodAndFunction {
  def main(args: Array[String]): Unit = {
    println(timeUUId)
  }


  //定义一个方法
  //方法m2参数要求是一个函数，函数的参数必须是两个Int类型
  //返回值类型也是Int类型
  def m1(f: (Int, Int) => Int): Int = {
    f (2, 6)
  }

  //定义一个函数f1,参数是两个Int类型，返回值是一个Int类型
  val f1 = (x: Int, y: Int) => x + y
  //再定义一个函数f2
  val f2 = (m: Int, n: Int) => m * n


  def max(a: Int, b: Int):Int = if (a > b) a else b  //定义方法

  val a: (Int, Int) => Int = max  //max会隐士转化成函数，赋给变量（函数是一等公民），变量必须要指定参数类型
  //val a: (Int, Int) => Int = max()  //报错

  var b = max _  //主动把方法转成函数，赋个变量，不用指定函数参数

  var doubler = (x: Int) => x + 10  //定义函数

  var c = doubler  //函数间赋值


  def hf():Int  => Int = x => x+1  //定义一个方法，参数：空；返回值：参数为Int的函数
  var d = hf()  //调用函数，返回值（函数）赋给一个变量
  var e = hf  //括号省略了

  //Partial Functions 偏函数

  val pf : PartialFunction[Int , String] = {
    case 1 => "One"
    case 2 => "Two"
    case _ => "Other"
  }
  val pf2 :Int => String = {
    case 1 => "One"
    case 2 => "Two"
    case _ => "Other"
  }

  def safeStringOp(s:String, f:String=>String) = {
    if (s != null) f(s) else s
  }
  //匿名函数
  val uuid = java.util.UUID.randomUUID().toString

  val timeUUId = safeStringOp(uuid,
    { s =>
      val now = System.currentTimeMillis
      val timed = s.take(24) + now
      timed.toUpperCase
    }
  )


}