scala学习笔记-函数与方法

Scala 方法是类的一部分，而函数是一个对象可以赋值给一个变量，也就是说Scala中的函数则是一个完整的对象，Scala 中的函数其实就是继承了 Trait 的类的对象。

区别:
1.Scala 中使用 val 语句可以定义函数，def 语句定义方法。
2.Scala中方法不是值，而函数是。所以一个方法不能赋值给一个val变量，而函数可以。

Scala中函数可以作为参数被传递

object MethodAndFunction {
  var f1: (Int, Int) => Int = (x: Int, y: Int) => x * y;

  var f2: (Int, Int) => Int = (x: Int, y: Int) => x + y;

  def m1(f: (Int, Int) => Int): Int = f(4, 5);

  def main(args: Array[String]): Unit = {
    val r1 = m1(f1);
    println(r1);//20

    val r2 = m1(f2);
    println(r2);//9
  }
}

Scala 允许你指明函数的最后一个参数可以是重复的，即我们不需要指定函数参数的个数，可以向函数传入可变长度参数列表。
Scala 通过在参数的类型之后放一个星号来设置可变参数(可重复的参数)。

object MethodAndFunction {

  def moreArgs(args: String*): Unit = {
    args.foreach((item: String) => println(item));
  }

  def main(args: Array[String]): Unit = {
    moreArgs("张三", "李四", "王五");
    println("============================");
    moreArgs("张三", "李四");
  }
}

Scala 可以为函数参数指定默认参数值，使用了默认参数，你在调用函数的过程中可以不需要传递参数，这时函数就会调用它的默认参数值，如果传递了参数，则传递值会取代默认值。实例如下：

object MethodAndFunction {
  def defaultArgValue(a : Int = 1): Unit = {
    println(a)
  }

  def main(args: Array[String]): Unit = {
    defaultArgValue()
    defaultArgValue(15)
  }
}

我们可以在 Scala 函数内定义函数，定义在函数内的函数称之为局部函数。

object MethodAndFunction {
  def out(a: Int, b: Int, c: Int): Unit = {
    def inner(b: Int, c: Int): Unit = {
      println(a + b + c);
    }

    inner(b, c);
  }

  def main(args: Array[String]): Unit = {
    out(1, 2, 3);
  }
}

Scala 偏应用函数是一种表达式，你不需要提供函数需要的所有参数，只需要提供部分，或不提供所需参数。
使用偏应用函数优化以上方法，绑定第一个 date 参数，第二个参数使用下划线(_)替换缺失的参数列表，并把这个新的函数值的索引的赋给变量

object MethodAndFunction {
  def log(date: Date, msg: String): Unit = {
    println(date + "======" + msg);
  }

  def main(args: Array[String]): Unit = {
    val date = new Date();
    //写法一
    log(date, "msg1");
    log(date, "msg2");
    log(date, "msg3");
    println();
    //偏应用函数写法
    val logWithDate = log(date, _: String);
    logWithDate("msg1");
    logWithDate("msg2");
    logWithDate("msg3");
  }
}

高阶函数（Higher-Order Function）就是操作其他函数的函数。
Scala 中允许使用高阶函数, 高阶函数可以使用其他函数作为参数，或者使用函数作为输出结果。

object MethodAndFunction {
  def m1(a: Int, b: Int): Int = a * b + 100;

  def m2(f: (Int, Int) => Int, a: Int, b: Int): Int = f(a, b);

  def m3(a: Int, b: Int): Int = m1(a, b);

  def main(args: Array[String]): Unit = {
    println(m2(m1, 10, 9))
    println(m3(10, 9))
  }
}

柯里化(Currying)指的是将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数为参数的函数。

object MethodAndFunction {
  def method(a: Int, b: Int): Int = a + b;

  def curryingMethod(a: Int)(b: Int): Int = a + b;

  def main(args: Array[String]): Unit = {
    val r1 = method(1,2);
    val r2 = curryingMethod(1)(2);

    println(r1);
    println(r2);
  }
}