隐式是scala的一大特性。

编写程序时使用它可以使代码精简。但是因为是隐式，所以在可读性上会受到一定影响。

隐式的分类

按照使用时机来分类，大概可以分为缺省参数，缺省对象，缺省类。
如果按照隐式的类别来分，可以分为隐式值，隐式视图，隐式类。

他们的对应关系大概如下
隐式值->缺省参数
隐式视图->缺省参数，缺省对象
隐式类->缺省对象

隐式值

scala> def max(implicit x:String) =x
max: (implicit x: String)String

scala> max
<console>:27: error: could not find implicit value for parameter x: String
       max
       ^

当我们定义一个方法，参数为隐式。我们去无参的调用它，这是编译器会去查找隐式值，但不幸，没有找到，报错。

scala> implicit var x="dsa"
x: String = dsa

scala> max
res35: String = dsa

现在我们定义了一个隐式值，再调用max，编译器可以找到一个对应的String隐式值，所以自动补上缺位。

scala> implicit var y="ha"
y: String = ha

scala> max
<console>:29: error: ambiguous implicit values:
 both method x of type => String
 and method y of type => String
 match expected type String
       max
       ^

这时我们也会想到，编译器是按类型进行查找，那么找到了多个String的隐式值怎么办？那么它会报错。

总结：当方法想以默认值执行的时候，可以应用隐式值。但是隐式值避免是String/int等基本类型，以免造成冲突。

隐式视图

首先我们定义一个分数，x是分子y是分母

class Rational(x:Int,y:Int) {
    require(y!=0)

    val up=x
    val down=y

      def add(r:Rational):Rational=
        new Rational(up*r.down+down*r.up,down*r.down)

}

现在如果我们现在调用该函数，但是我们给予的参数是一个整数

val oneHalf=new Rational(1,2)
    oneHalf+2

Error:(4, 13) type mismatch;
 found   : Int(2)
 required: Rational
    oneHalf+2

编辑器发现给的参数不对，会去寻找会不会有隐式转换，可惜没找到，现在我们给他一个隐式转换。

  def main(args: Array[String]): Unit = {
    implicit def intToRational(x:Int):Rational=new Rational(x,1)
    val oneHalf=new Rational(1,2)
    print(oneHalf+2)
  }

Rational@f6c48ac
Process finished with exit code 0

现在正确了，因为返回的是一个Rational，所以会是以@开头后面跟一串字符，可以重写方法中的toString方法，那么打印的会是toString的返回值。

现在我们希望有一个方法，可以返回一个分母加分子

class Rational(x:Int,y:Int) {
    require(y!=0)

    val up=x
    val down=y

      def +(r:Rational):Rational=
        new Rational(up*r.down+down*r.up,down*r.down)

      def addxy()=x+y
}

在一个类start中，它也希望能调用该方法

  val s=new start
    s.addxy()

Error:(6, 7) value addxy is not a member of start
    s.addxy()

不幸，没有找到。例子有些脑残。但是我们很容易想到这种情况可以用隐式解决。

implicit def sToRational(s:start):Rational=new Rational(1,1)      
 val s=new start                                                  
 s.addxy()                                                        

通过隐式转换，可以把s转为一个1/1的Rantional对象，从而进行调用。

联想：RDD中没有reduceByKey等函数，他们都在PairRDDFunctions中，所以使用函数时必须导入Import org.apache.spark.SparkContext._

这也不禁让我想到前些日子，调用JavaDStream的mapToPair对象无法返回JavaPairDStream
虽然导入了import org.apache.spark.streaming.api.java.JavaPairDStream;
但无法奏效，必须导入
import org.apache.spark.streaming.api.java.*;

总结:如果一个对象调用一个函数，参数不是该函数需要类型的参数，这是编译器会去寻找隐式转换。如果这个对象没有这个方法，那么编译器会去寻找一个有该方法的隐式对象。

隐式类

隐式类，可以在缺省类时被使用。还有动态增加函数的作用。在这里不细讲。

scala> implicit class StringSize(val s: String){
     | def sizes=s.length
     | }
defined class StringSize

scala> "/".sizes
res37: Int = 1

果然构造类参数换为其他对象的时候，就成了动态增加函数啦。