scala implicit 隐式转换

原创 2014年04月28日 16:53:08

我们经常在scala 源码里上看到类似implicit这个关键字。

一开始不太理解,后来看了看,发现implicit这个隐式转换是支撑scala的易用、容错以及灵活语法的基础。

我们经常使用的一些集合方法里面就用到了implicit,比如:

  def flatMap[B, That](f: A => GenTraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = {

1. 隐式转换函数的定义:

我们在scala repl里定义一个方法foo,接受一个string的参数,打印出message

 当我们传入字符串参数"2"的时候,输出2

 但是当传入的类型是int而不是string的时候,出现类型不匹配异常。

 如果我们想支持隐式转换,将int转化为string,可以定义一个隐式函数,def implicit intToString( i : Int) = i.toString

 这里注意一下这个隐式函数的输入参数和返回值。

 输入参数:接受隐式转换入参为int类型

 返回值: 返回结果是string.

scala> def foo(msg : String) = println(msg)
foo: (msg: String)Unit

scala> foo("2")
2

scala> foo(3)
<console>:9: error: type mismatch;
 found   : Int(3)
 required: String
              foo(3)
                  ^

scala> implicit def intToString(i:Int) = i.toString
warning: there were 1 feature warning(s); re-run with -feature for details
intToString: (i: Int)String

scala> foo(3)
3
scala> def bar(msg : String) = println("aslo can use implicit function intToString...result is "+msg)
bar: (msg: String)Unit
scala> bar(33)
aslo can use implicit function intToString...result is 33

总结一下,我的理解是:隐式函数是在一个scop下面,给定一种输入参数类型,自动转换为返回值类型的函数,和函数名,参数名无关。

这里intToString隐式函数是作用于一个scop的,这个scop在当前是一个scala repl,超出这个作用域,将不会起到隐式转换的效果。


为什么我会这么定义隐式函数,下面我再定义一个相同的输入类型为int,和返回值类型为string的隐式函数名为int2str:

scala> implicit def int2str(o :Int) = o.toString
warning: there were 1 feature warning(s); re-run with -feature for details
int2str: (o: Int)String

scala> bar(33)
<console>:13: error: type mismatch;
 found   : Int(33)
 required: String
Note that implicit conversions are not applicable because they are ambiguous:
 both method intToString of type (i: Int)String
 and method int2str of type (o: Int)String
 are possible conversion functions from Int(33) to String
              bar(33)
                  ^

跑出了二义性的异常,说的是intToString和int2str这2个隐式函数都是可以处理bar(33)的,编译器不知道选择哪个了,呵呵。。

证明了隐式函数和函数名,参数名无关,只和输入参数与返回值有关。


2. 隐式函数的应用

我们可以随便的打开scala函数的一些内置定义,比如我们最常用的map函数中->符号,看起来很像php等语言。

但实际上->确实是一个ArrowAssoc类的方法,它位于scala源码中的Predef.scala中。下面是这个类的定义:

  final class ArrowAssoc[A](val __leftOfArrow: A) extends AnyVal {
    // `__leftOfArrow` must be a public val to allow inlining. The val
    // used to be called `x`, but now goes by `__leftOfArrow`, as that
    // reduces the chances of a user's writing `foo.__leftOfArrow` and
    // being confused why they get an ambiguous implicit conversion
    // error. (`foo.x` used to produce this error since both
    // any2Ensuring and any2ArrowAssoc pimped an `x` onto everything)
    @deprecated("Use `__leftOfArrow` instead", "2.10.0")
    def x = __leftOfArrow

    @inline def -> [B](y: B): Tuple2[A, B] = Tuple2(__leftOfArrow, y)
    def →[B](y: B): Tuple2[A, B] = ->(y)
  }
  @inline implicit def any2ArrowAssoc[A](x: A): ArrowAssoc[A] = new ArrowAssoc(x)

我们看到def ->[B] (y :B)返回的其实是一个Tuple2[A,B]类型。

我们定义一个Map:

scala> val mp = Map(1->"game1",2->"game_2")
mp: scala.collection.immutable.Map[Int,String] = Map(1 -> game1, 2 -> game_2)

这里 1->"game1"其实是1.->("game_1")的简写。

这里怎么能让整数类型1能有->方法呢。

这里其实any2ArrowAssoc隐式函数起作用了,这里接受的参数[A]是泛型的,所以int也不例外。

调用的是:将整型的1 implicit转换为 ArrowAssoc(1)

看下构造方法,将1当作__leftOfArrow传入。

->方法的真正实现是生产一个Tuple2类型的对象(__leftOfArrow,y ) 等价于(1, "game_id")

这就是一个典型的隐式转换应用。


其它还有很多类似的隐式转换,都在Predef.scala中:

例如:Int,Long,Double都是AnyVal的子类,这三个类型之间没有继承的关系,不能直接相互转换。

在Java里,我们声明Long的时候要在末尾加上一个L,来声明它是long。

但在scala里,我们不需要考虑那么多,只需要:

scala> val l:Long = 10
l: Long = 10

这就是implicit函数做到的,这也是scala类型推断的一部分,灵活,简洁。

其实这里调用是:

val l : Long = int2long(10)


最后的总结:

1. 记住隐式转换函数的同一个scop中不能存在参数和返回值完全相同的2个implicit函数。

2. 隐式转换函数只在意 输入类型,返回类型。

3. 隐式转换是scala的语法灵活和简洁的重要组成部分。


原创,转载请注明出自:http://blog.csdn.net/oopsoom/article/details/24643869

-EOF-

相关文章推荐

scala 隐式详解(implicit关键字)

掌握implicit的用法是阅读spark源码的基础,也是学习scala其它的开源框架的关键,implicit 可分为: 隐式参数 隐式转换类型 隐式调用函数 1.隐式参数当我们在定义方法时,可以把最...

Scala隐式( implicit)编程彻底实战之编程进阶(7)

一:隐式详解1:概念: 隐式(implicit)是Scala的一个强大特性,同时也是一个可能存在正义的特性。使用隐式能够减少代码,能够向已有类型中注入新的方法,也能够创建领域特定语言(DSL...
  • erfucun
  • erfucun
  • 2016年08月16日 20:20
  • 2171

Scala学习笔记09--隐式转化implicit

scala 使用 implicit 隐式转化时 ,  scala 编辑器发现对象的类型不匹配时,不会直接报错,而会在代码中尝试匹配implicit声明的object, 当然,相同方法签名的类...

第16课:Scala implicits编程彻底实战

Scala,Implict,隐式转换

scala implicit 隐式转换

我们经常在scala 源码里上看到类似implicit这个关键字。 一开始不太理解,后来看了看,发现implicit这个隐式转换是支撑scala的易用、容错以及灵活语法的基础。 我们经常使...

Scala中隐式转换(implicit conversion)的优先顺序

在学习Scala的时候,隐式转换(implicit conversion)这个特性让我实在是闹不住啊。于是乎一边试用一边感慨:真的是太强大,太方便了。不过,越是强大且方便的东西,越容易用出毛病来。在我...

scala隐式参数(implicit)

SBinary 和 Scalacheck的一部分库,广泛使用了隐式参数。让人联想起了Haskell(一种函数式编程语言)的编程风格,我真心的希望在Scala中这种编程风格更加广泛。这是一种非常有用的技...

编译class文件“$”符号的含义

class文件中“$”的含义

Scala Actor并发编程

Java中的并发编程主要通过线程实现的,通过共享资源的机制实现并发,但会面临着死锁的问题。在Scala中,是通过消息传递来实现并发的,而Actor正是实现消息传递的。 Scala的actor...

scala 中隐式转换 implicit的应用

下面是一个Rational的类 class Rational(n: Int, d: Int) { require(d != 0) private val g = gcd(n.abs,...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:scala implicit 隐式转换
举报原因:
原因补充:

(最多只允许输入30个字)