Scala学习（二）方法和函数

object DemoTwo {

    //定义函数add
    def add(a: Int, b: Int)： Int={
        a+b
    }

    def main(args: Array[String]): Unit = {
        // 调用函数
        print(add(1, 2))
    }
}

object DemoTwo {
    
    // add3方法拥有2个参数，第一个参数是一个函数， 第二个为Int类型的参数
    def add3(a:Int => Int, b: Int) = {
        a(b) + b // x * 10 + 6
    }

    val f1 = (x: Int) => x * 10

    def main(args: Array[String]): Unit = {
        val r3 = add3(f1, 6)
        println(r3)
    }
　　// f1 传递的是函数名，6传递的是值
}

//定义一个可变参数的方法
def methodManyParams(a: String*) ={ 
    for (p <- a) {println(p)}
}

//调用
methodManyParams("中华", "人民", "共和国")

//带默认的参数列表
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) // 调用如果执行修改某一个具体的参数值的话, 可以指定参数名称

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

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

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

//我们看下这个方法的定义, 求 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)

object DemoTwo {

    def main(args: Array[String]): Unit = {
        print(fun("a"))

    }
    
    // 定义偏函数   def 函数名：PartialFunction（参数类型，返回值类型）={函数体}，如下实例
    def fun: PartialFunction[String, Int]={
        case "one" => 1
        case "two" => 2
        case _ => 0
    }

}