scala中的泛型

1.泛型类
Scala中的泛型类使用[T]来定义，如：

class Pair[T, S](val first: T, val second: S)
object Pair {
    def apply[T, S](f: T, s: S) = new Pair(f, s)
}

在实例化的时候，会根据参数来推断类型

    val pair1 = new Pair(42, "String") //Pair[Int, String]
    val pair2 = new Pair(42, 28) //Pair[Int, Int]

2.泛型函数

    def getMiddle[T](a: Array[T]) = a(a.length / 2)
    getMiddle(Array(1, 2, 3, 4)) //将会调用getMiddle[Int]
    val f = getMiddle[String] _ //这是具体的函数被保存到f

3.类型变量界定
有时候需要对类型变量进行限制。比如让对偶的类型相同,然后在获取其中较小的值.
这时候我们可以使用，上界T <: Comparable[T],表示子类，当然还有表示超类的
R >: T表示R是T的超类

//  泛型上届 <: 下届 >:
    class Pair[T <: Comparable[T]](val first: T, val second: T) {
    //  获取对偶中比较小的值
        def smaller = if (first.compareTo(second) < 0) first else second
    }
    val p = Pair("string", "int")
    println(p.smaller) 

4.视图界定
在上一个Pair类中，不能new一个Pair(4,1),这是因为scala中的Int不是comparable的子类，需要将其隐式转换为RichInt，这就需要使用到视图界定：T <% Comparable[T]，
<%关系意味着T可以被隐式转化为 Comparable[T]

//  泛型下届 <: 
    class Pair[T <% Comparable[T]](val first: T, val second: T) {
    //  获取对偶中比较小的值
        def smaller = if (first.compareTo(second) < 0) first else second
    }
    val p = Pair(4, 1)
    println(p.smaller) 

单纯的比较大小而言Ordered比Comparable更好：

//  Ordered特质比Comparable更好，在其基础上提供了关系操作符
    class Pa[T <% Ordered[T]](val first: T, val second: T) {
        //  获取对偶中比较小的值
        def smaller = if (first.compareTo(second) < 0) first else second
//      使用Ordered获取大值
        def bigger = if(first > second) first else second
    }

5.上下文界定
视图界定T<%V要求必须存在一个从T到V的隐式转化。上下文界定的形式为T:M，
其中M是别的泛型。他要求要有一个类型为M[T]的隐式值。例如：

    class Pair[T:Ordering](val first: T, val second: T) {
        //  使用隐式转化将
        def smaller(implicit ord:Ordering[T]) = if (ord.compare(first,second) < 0) first else second
    }
    val pa12 = new Pa1(2,3)
    println(pa12.smaller)

6.Manifest上下文界定
如果要实例化一个泛型数组Array[T]的话,我们需要一个Manifest[T]对象。例如，T是Int，你会希望虚拟机的多一个int[]。在scala中Array只是一个类，编译器不会对他做任何特殊处理。如果需要使用泛型函数构造泛型数组，你就需要传入Manifest对象 。由于他是构造器的隐式参数，你可以使用上下文界定。

def makePair[T:Manifest](first:T,second:T)={
        val r = new Array[T](2)
        r(0) = first
        r(1) = second
        r
    }
val arr = makePair(4, 9)

为何这么复杂？在JVM中，泛型相关的类型会被擦除，只会有一个makePair方法，却要处理所有的类型T。
7.多重界定的写法
上下界同时存在
T >: Lower <: Upper
不可以有多个上下界，但可以要求一个类型带有多个特质
T <: Comparable[T] with Serializable with Cloneable
多个视图界定
T <% Comparable[T] <% String
多个上下文界定
T : Ordering : Manifest