杂记四：scala 柯理化和隐式转换

1、柯理化

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

实例
首先我们定义一个函数:

def add(x:Int,y:Int)=x+y

那么我们应用的时候，应该是这样用：add(1,2)
现在我们把这个函数变一下形：

def add(x:Int)(y:Int) = x + y

那么我们应用的时候，应该是这样用：add(1)(2),最后结果都一样是3，这种方式（过程）就叫柯里化。

实现过程
add(1)(2) 实际上是依次调用两个普通函数（非柯里化函数），第一次调用使用一个参数 x，返回一个函数类型的值，第二次使用参数y调用这个函数类型的值。
实质上最先演变成这样一个方法：

def add(x:Int)=(y:Int)=>x+y

那么这个函数是什么意思呢？ 接收一个x为参数，返回一个匿名函数，该匿名函数的定义是：接收一个Int型参数y，函数体为x+y。现在我们来对这个方法进行调用。

val result = add(1) 

返回一个result，那result的值应该是一个匿名函数：(y:Int)=>1+y
所以为了得到结果，我们继续调用result。

val sum = result(2)

最后打印出来的结果就是3。

完整实例
下面是一个完整实例：

object Test {
     
   def main(args: Array[String]) {
     
      val str1:String = "Hello, "
      val str2:String = "Scala!"
      println( "str1 + str2 = " +  strcat(str1)(str2) )
   }

   def strcat(s1: String)(s2: String) = {
     
      s1 + s2
   }
}

执行以上代码，输出结果为：

$ scalac Test.scala
$ scala Test
str1 + str2 = Hello, Scala!

2、隐式转换

我们需要某个类中的一个方法，但是这个类没有提供这样的一个方法，所以我们需要隐式转换，转换成提供了这个方法的类，然后再调用这个方法。

定义在公共对象中的隐式转换：

import scala.io.Source
import java.io.File
 

//这里的RichFile相当于File的增强类 需要将被增强的类作为参数传入构造器中
class RichFile(val file: File) {
     
  def read = {
     
      Source.fromFile(file.getPath).mkString
  }
}
 
//implicit是隐式转换的关键字 这里定义一个隐式转换函数把当前类型转换成增强的类型（函数名称一般是source2target）
object Context {
     
    //File --> RichFile
    implicit def file2RichFile(file: File) = new RichFile(file)
}
 
object Hello_Implicit_Conversions {
     
    def main(args: Array[String]): Unit = {
     
        //导入隐式转换
        import Context.file2RichFile
        //File类本身没有read方法 通过隐式转换完成
        //这里的read方法是RichFile类中的方法  需要通过隐式转换File --> RichFile
        println(new File("E:\\projectTest\\1.txt").read)
      
    }
}

定义在原类型的伴生对象中：

class Person(val name: String)
// 在伴生对象中定义隐式转换函数
object Person{
     
  implicit def person2Thor(p: Person): Thor = new Thor(p.name)
}

class Thor(val name: String) {
     
  def hammer(): Unit = {
     
    println(name + "举起雷神之锤")
  }
}

// 使用示例
object ScalaApp extends App {
     
  new Person("普通人").hammer()
}

隐式参数

object Context_Implicits {
     
    implicit val default: String = "Java"
}

object Param {
     
    //函数中用implicit关键字 定义隐式参数
    def print(context: String)(implicit language: String){
     
        println(language+":"+context)
    }
}

object Implicit_Parameters {
     
    def main(args: Array[String]): Unit = {
     
        //隐式参数正常是可以传值的，和普通函数传值一样  但是也可以不传值，因为有缺省值(默认配置)
        Param.print("Spark")("Scala")   //Scala:Spark
        
        import Context_Implicits._
        //隐式参数没有传值，编译器会在全局范围内搜索 有没有implicit String类型的隐式值 并传入
        Param.print("Hadoop")          //Java:Hadoop
    }
}