scala隐式转换

1、 隐式转换函数
隐式转换的深层机制是隐式转换函数（implicit conversion method），隐式函数前加上implicit
如将Double转换成Int

implicit def Double2Int(x:Double)=x.toInt
val x:Int=1.55   //x=1

隐式函数与函数的标签有关，即于输入输出类型有关，与函数名称无关
隐式转换函数可以快速的扩展类的功能。

class superclass{
def fly()=println(“Superman flying”)
}
class person
object implicitFunction extends App{
implicit def person2superPerson(p:person)=new superclass
val p=new person
p.fly()    //Superman flying
}

2、 隐式类与隐式对象
隐式类是在class前加上implicit关键字

class person
object implicitFunction extends App{
implicit class superclass（p:person）{
def fly()=println(“Superman flying”)
}

val p=new person
p.fly()    //Superman flying
}

隐式类的构造函数是隐式函数

隐式参数、隐式值
隐式参数只能在函数列表中出现一次，implicit作用域是整个函数参数，科里化函数的implicit只能放在最后一个参数中
匿名函数不能使用隐式参数
带有隐式参数的函数不能使用其部分应用函数

def sum(implicit x:Int,y:Int)=x+y
implicit val x:Int=5
sum   //编译器自动在相应作用域中查找对应的隐式值
//实际调用sum（5+5）

3、 类型证明中的隐式转换
类型证明，也称类型约束，作用是进行类型测试，
T=:=U
T<:

object typeConstraint extends App{
def test[T](name:T)(implicit ev:T<:<java.io.Serializable)={name}
//String类型实现了Serializable接口，属于Serializable的子类
println(test(“张三“))
println(test(165))//error!Int类型没有实现Serializable接口，不属于Serializable的子类
}

<:<和<:的·差别：
<:类型不匹配时，使用类型推断采用父类进行匹配
<:<严格匹配，不会采用父类进行匹配，隐式转换在此不管用。

4、 上下文界定、视图界定中的隐式转换
Ordering混入java中的Comparator接口，外部比较器
Ordered混入Comparable接口，内部比较器

java中Comparator接口使用实例

     public class Person{
private String name;
public String getName(){
return name;
}
public void setName(String name){
tis.name=name;
}
public Person(String name){
this.name=name;
}
}
public class PersonComparator implements Comparator<Person>{
@override
public int compara(Person o1,Person o2){
if(o1.getName().equalsIgnoreCase(o2.getName()))
{return 1;}
else
{return -1;}
}
public static void main(String[] args)
{
PersonComparator pc=new PersonComparator();
Person p1=new Person(“张三”)；
Person p2=new Person(“张三2“)；
if(pc.compara(p1,p2)>0)
System.out.pintln(p1.getName());
else
System.out.println(p2.getName());

}

}

Comparable接口在java中的运用。

public class Person implements Comparator<Person>{
private String name;
public String getName(){
return name;
}
public void setName(String name){
tis.name=name;
}
public Person(String name){
this.name=name;
}
@override
public int comparator(Person o)
{
if(name.equalsIgnoreCase(o.getName()))
{
return 1;}
else
{
return -1;
}
}
}
public class PersonComparable{
public static void main(String[] args)
{
Person p1=new Person(“张三”)；
Person p2=new Person(“张三2“)；
if(p1.compara(p2)>0)
System.out.pintln(p1.getName());
else
System.out.println(p2.getName());

}

}

所以ordered是内部比较器

case class Student(val name:String) extends Ordered{
override def compara(that:Student):Int={
if(this.name==that.name)
1
else
-1
}
}
class pairComparable[T<:Ordered[T]](val first:T,val second:T){
def smaller()={
if(first<second)
first
else
second
}
}
object OrderedViewBound extends App{
val p=new pairComparable(Student(“张三“),Student(“张三2”))
println(p.smaller)
}

界图转换
不仅仅是指定类层次的类，还可以是隐式转换后的类

\\利用<%符号对泛型S进行限定，即S可以是在类继承层次结构中实现了Comparable的类
\\也可以是能够进行隐式转换得到的类
case class Student[T,S<%Comparable[S]](var name;String,var height;Int)
object viewBoundextends App{
val s=Student(“john”,”170”)
val s1=Student(“john”,170)
println(s2)//Student(“john”,170)
}

上下文界定类型参数为T:M，其中M是一个泛型，要求存在一个M[T]类型的隐式值。

//类型参数可以有一个形式为T:M的上下文界定，其中M是另一个泛型类型。它要求作用域中存在一个类型为M[T]的隐式值
class Pair_Implicits[T: Ordering](val first: T, val second: T) { //Ordering[T]
def bigger(implicit ordered: Ordering[T]) =
if (ordered.compare(first, second) > 0) first else second
}
class Pair_Implicitly[T: Ordering](val first: T, val second: T) {
def bigger = if (implicitly[Ordering[T]].compare(first, second) > 0)
first else second
}
class Pair_Implicitly_Odereded[T: Ordering](val first: T, val second: T) {
def bigger = {
import Ordered._
if (first > second) first else second
}
}
object Context_Bounds_Internals {
def main(args: Array[String]): Unit = {
println(new Pair_Implicits(7, 9).bigger)
println(new Pair_Implicitly(7, 9).bigger)
println(new Pair_Implicitly_Odereded(7, 9).bigger)
}
}

发生隐式转换的条件：
1） 隐式转换函数必须在有效的作用域内才能生效
2） 当方法中的参数类型与实际类型不一致时，编译器尝试进行隐式转换，
3） 当调用类中不存在的对象或方法时，会自动将对象进行隐式转换。
不发生隐式转换的条件：
1） 转换存在二义性
2） 隐式转换不会嵌套进行