隐式是scala的一大特性。
编写程序时使用它可以使代码精简。但是因为是隐式，所以在可读性上会受到一定影响。
隐式的分类
按照使用时机来分类，大概可以分为缺省参数，缺省对象，缺省类。
如果按照隐式的类别来分，可以分为隐式值，隐式视图，隐式类。
他们的对应关系大概如下
隐式值->缺省参数
隐式视图->缺省参数，缺省对象
隐式类->缺省对象
隐式值
scala> def max(implicit x:String) =x
max: (implicit x: String)String
scala> max
: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
: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
果然构造类参数换为其他对象的时候，就成了动态增加函数啦。