scala中的泛型编程

Scala中的泛型编程

简介

在Java或者C++里面，像列表（List）这些数据结构，在编写的时候，都不需要指定其中元素的类型，而是构造的时候指定，这一特性就称为泛型。同样，Scala中也提供了泛型，而且功能比Java的泛型更加强大。

List strList = new ArrayList();
strList.add("one");
strList.add("two");
strList.add("three");

String one = strList.get(0); 
// 泛型拿数据不必进行类型转换，不使用泛型的话需要对类型进行转换

类型参数化(type parameterlization)

scala中的泛型称为类型参数化(type parameterlization)。语法跟java不一样，使用[]表示类型。

方法的泛型

一个使用类型参数化的方法：

def position[A](xs: List[A], value: A): Int = {
    xs.indexOf(value)
}

position(List(1,2,3), 1) // 0
position(List("one", "two", "three"), "two") // 1

稍微复杂点的类型参数化，实现一个map函数，需要一个List和一个函数作为参数：

普通的map方法：

List(1,2,3) map { _ * 2 }  // List[Int] = List(2,4,6)
List(1,2,3) map { _ + "2" }  // List[String] = List(12, 22, 32)

使用泛型实现的map方法：

def map[A, B](list:List[A], func: A => B) = list.map(func)

map(List(1,2,3), { num: Int => num + "2" }) // List[String] = List(12, 22, 32)
map(List(1,2,3), { num: Int => num * 2 }) // List[Int] = List(2, 4, 6) 

类的泛型

可以给一个类添加泛型，这样，在编写的时候就不需要考虑这一类型的具体情况，而是使用一个标记来注明。

class Pair[K, V] (val key: K, val value: V)

类似构造函数，如果要继承的类包括泛型，那么继承时也需要写泛型的类型：

class SimplePair[T] (key: T, value: T) extends Pair[T, T](key, value)

不过这里Pair的泛型其实是可以通过构造函数传值的类型猜测出来的，所以可以省略：

class SimplePair[T] (key: T, value: T) extends Pair(key, value)

这样，类名在声明或者新建实例的时候也需要写明泛型的类型：

val p1: Pair[Int, String] = new Pair[Int, String](1, "abc")
val p2 = new Pair(1, "abc") //可以猜到的类型和泛型设定都被省略掉了

泛型的上下界

类型变量界定是指在泛型的基础上，对泛型的范围进行进一步的界定，从而缩下泛型的具体范围。

在定义泛型的时候，用<:和>:规定泛型元素的上下界（在某些地方也会用这两个符号表示子类和父类），

```scala
class A
class B extends A
class C extends B
class D extends C
class E extends D

class T1[T >: B]
class T2[T <: B]
class T3[T >: D <: B]
class T4[T <: B with Ordered[T]]    // 可以使用with关键字对多个特征进行限定
                                    // 在继承B的同时还要求有可排序的性质

new T1[A]
//new T1[C] 不能通过编译

//new T2[A] 不能通过编译
new T2[C]

//new T3[A] 不能通过编译
new T3[B]
new T3[C]
new T3[D]
//new T3[E] 不能通过编译
````
这样做的作用有很多，比如，可以限定方法的实现

下面的类是不能通过编译的，因为泛型T在编译的时候不能确定其具体类型，而并不是所有的类中都存在compareTo方法。





<div class="se-preview-section-delimiter">div>

```scala
class TypeVariableBound {
  def compare[T](first:T,second:T)={
    if (first.compareTo(second)>0) 
      first 
    else 
      second
  }
}

object TypeVariableBound{
  def main(args: Array[String]): Unit = {
      val tvb=new TypeVariableBound
      println(tvb.compare("A", "B")) 
  }
}

如果在使TypeVariableBound类编译通过，此时可以利用类型变量界定对泛型T进行界定，指明所有的泛型T都实现了Comparable接口，代码如下：

class TypeVariableBound {
  //采用<:进行类型变量界定
  //该语法的意思是泛型T必须是实现了Comparable
  //接口的类型
  def compare[T <: Comparable[T]](first:T,second:T)={
    if (first.compareTo(second)>0) 
      first 
    else 
      second
  }
}

object TypeVariableBound{
  def main(args: Array[String]): Unit = {
      val tvb=new TypeVariableBound
      //由于String类型实现了Comparable接口
      //下面这种使用方式是合法的
      println(tvb.compare("A", "B"))
   }
}

当然这只是其中一个应用而已。

可以对比一下Java的语法

def upperBound[A <: Animal](list: ListBuffer[A]): Unit = { 
    list += new Animal("123")   // compile error
    val obj: AnyRef = list(0)   // ok
    val a1: Animal = list(0)    // ok
    val a2: Cat = list(0)       // compile error
} 

def lowerBound[A >: Animal](list: ListBuffer[A]): Unit = { 
    list += new Animal()        // ok
    list += new Cat()           // ok
    val obj1: Any = list(0)     // ok
    val obj2: Animal = list(0)  // compile error
}

public void upperBound(List l) {
    Object obj = l.get(0); // Number是Object的子类，使用Object可以代替Number。
    Number num = l.get(0);
    Integet i = l.get(0); // compile error
    l.add(new Integer(1)); // compile error
}

public static void lowerBound(List l) {
    l.add(new Integer(1));
    l.add(new Float(2));
    Object obj = l.get(0);
    Number num = l.get(0); // compile error
}

视图界定（View Bound)

类型变量界定建立在类继承层次结构的基础上，但有时候这种限定不能满足实际要求。如果希望跨越类继承层次结构时，可以使用视图界定来实现的，其后面的原理是通过隐式转换来实现。视图界定利用<%符号来实现，在上一节中提到：

//使用的是类型变量界定
case class Student[T,S <: Comparable[S]](var name:T,var height:S)
object ViewBound extends App{

  val s= Student("john","170")
  //下面这条语句不合法，这是因为
  //Int类型没有实现Comparable接口
  val s2= Student("john",170)
}

上面这个问题可以通过视图界定来解决，代码如下：

//利用<%符号对泛型S进行限定
//它的意思是S可以是Comparable类继承层次结构
//中实现了Comparable接口的类
//也可以是能够经过隐式转换得到的类,该类实现了
//Comparable接口
case class Student[T,S <% Comparable[S]](var name:T,var height:S)


object ViewBound extends App{
  val s= Student("john","170")
  //下面这条语句在视图界定中是合法的
  val s2= Student("john",170)
}

Int类型会隐式转换为RichInt类，而RichInt类属于Comparable继承层次结构

协变和逆变

协变(covariance)：对于一个带类型参数的类型，比如List[T]，如果对A及其子类型B，满足List[B]也符合List[A]的子类型，那么就称为协变，用加号表示。比如 MyType[+A]。

逆变(contravariance)：如果List[A]是List[B]的子类型，用减号表示。比如MyType[+B]。

如果一个类型支持协变或逆变，则称这个类型为可变的(variance)，否则称为不可变的(invariant)。在java里，泛型类型都是不可变的，比如List并不是List