03-Scala中的方法和函数

1、方法的定义与调用

方法的返回值类型可以不写，编译器可以自动推断出来，但是对于：
返回值使用了return关键字的；递归函数，必须指定返回类型；

/**
  * 方法的定义及调用
  *
  * 定义方法的格式为:
  * def methodName ([list of parameters]) : [return type] = {}
  * 如果不使用等号和方法体，则隐式声明抽象(abstract)方法。
  */
object ScalaMethod extends App{

    // 定义个sum方法, 改方法有2个参数, 参数类型为整型, 方法的返回值为整型
    def sum(a:Int, b: Int): Int = {
        a + b
    }
    // 调用
    val result1 = sum(1, 5)
    println(result1)

    // 改方法没有任何参数, 也没有返回值
    def sayHello1 = println("Say BB1")
    def sayHello2() = println("Say BB2")
    sayHello1 // 如果方法没有() 调用时不能加()
    sayHello2 // 可是省略(), 也可以不省略
}

方法可转换为函数:

2、函数的定义与调用

函数定义方式一:
调用: f1(2) , 其中f1为函数的引用, 也可以叫做函数名. function1表示一个参数的函数.

函数定义方式二:

下面为没有任何参数的函数, 函数的返回值为Int类型.

3、传值调用与传名调用

通常，函数的参数是传值参数; 也就是说，参数的值在传递给函数之前确定。
其实, 在Scala中, 我们方法或者函数的参数可以是一个表达式, 也就是将一个代码逻辑传递给了某个方法或者函数.

/**
  * scala 的
  *     传名调用(call-by-name)
  *     传值调用(call-by-value)
  */
object ScalaCallName {
    var money = 90
    def huaqian() = {
        money -= 5
        money
    }

    def printCallName(f: => Int) = {
        for (i <- 0 to 3) {
            println(f)
        }
    }

    def printCallValue(v: Int) = {
        for (i <- 0 to 3) {
            println(v)
        }
    }

    def main(args: Array[String]): Unit = {
//        printCallName(huaqian())
        printCallValue(huaqian())
    }
}

4、可变参数函数

// 定义一个可变参数的方法
def methodManyParams(a: String*) = {
    for (p <- a) {
        println(p)
    }
}
// 调用
methodManyParams("中华", "人民", "共和国")

5、默认参数值函数

// 带默认的参数列表
def add(a: Int = 1, b: Int = 7): Int = {
    println(s"a + b = ${a + b}" )
    a + b
}
// 调用
add(2)  //  带有默认值a的参数, 调用时可以不传
add(b=9, a=2) // 调用时, 可以指定具体的参数值
add(b=18) // 调用如果执行修改某一个具体的参数值的话, 可以指定参数名称

6、高阶函数

// 高阶函数: 将其他函数作为参数或其结果是函数的函数
// 定义一个方法, 参数为带一个整型参数返回值为整型的函数f 和 一个整型参数v, 返回值为一个函数
def apply(f: Int => String, v: Int) = f(v)

// 定义一个方法, 参数为一个整型参数, 返回值为String
def layout(x: Int) = "[" + x.toString() + "]"

// 调用
println(apply(layout, 10))

7、柯里化(Currying)

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

// 我们看下这个方法的定义, 求2个数的和
def add(x: Int, y: Int) = x + y
// 那么我们应用的时候，应该是这样用：add(1,2)
// 现在我们把这个函数变一下形：
def add(x:Int)(y:Int) = x + y
// 那么我们应用的时候，应该是这样用：add(1)(2),最后结果都一样是3，这种方式（过程）就叫柯里化。经过柯里化之后，函数的通用性有所降低，但是适用性有所提高。

// 分析下其演变过程
def add(x: Int) = (y: Int) => x + y

// (y: Int) => x + y 为一个匿名函数, 也就意味着add方法的返回值为一个匿名函数
// 那么现在的调用过程为
val result = add(2)
val sum1 = result(3)
val sum2 = result(8)

8、偏函数

被包在花括号内没有match的一组case语句是一个偏函数，它是PartialFunction[A, B]的一个实例，A代表参数类型，B代表返回类型，常用作输入模式匹配。

object PartialFuncDemo  {

  def func1: PartialFunction[String, Int] = {
    case "one" => 1
    case "two" => 2
    case _ => -1
  }

  def func2(num: String) : Int = num match {
    case "one" => 1
    case "two" => 2
    case _ => -1
  }

  def main(args: Array[String]) {
    println(func1("one"))
    println(func2("one"))
  }
}