Scala的泛型

Scala的泛型

 泛型介绍：泛型用于指定方法或类可以接受任意类型参数，参数在实际使用时才被确定，泛型可以有效 地增强程序的适用性，使用泛型可以使得类或方法具有更强的通用性。泛型的典型应用场景 是集合及集合中的方法参数。
 泛型方法：指定方法可以接受任意类型参数。
 泛型类：指定类可以接受任意类型参数。
例：

object GenericTypeTest01 {
def main(args: Array[String]): Unit = {
println(new Student11[String,Int]("黄渤",33).name)
println(new Student12[String,Int]("zs",18).name)
println(new Student22[String,Int]("zs",8).age)
  }
}
class Student12[T,S](var name:T,var age:S){}
class Student11[T,S](var name:T, var age:S){}
class Person11[T](var name:T)
class Student22[T,S](name:T,var age:S) extends Person11(name) {}

 1. scala类型变量界定

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

object Test01 {
  def main(args: Array[String]): Unit = {
    var generic=new Generic
    val result: Int = generic.compare("aa","bb")
  }
}
class Generic{
  /**
    *T<:Comparable 表示compare方法中如果输入的类型处于Comparable类对应的继承体系中，则是合法的，否则编译不通过
    * 作用是：当调用泛型的方法是，但是不知道这个泛型是否有这个方法，此时使用泛型的类型变量界定，缩写范围，使得，泛型中有这个方法
    */
  def compare[T<:Comparable[T]](first:T,second:T)={
    val result=if(first.compareTo(second)>0) 1 else 0
    result
  }
}

 2. scala视图界定

  类型变量界定建立在类继承的层次上，但有时候这种限定不能满足实际要求，如果希望跨越类继承层次结构时，可以使用视图界定来实现，原理是通过隐式转换来实现。
  隐含参数和方法也可以定义隐式转换，称作视图。视图的绑定从另一个角度看就是 implicit 的转换。其实视图的绑定就是为了更方便的使用隐式转化，视图界定利用<%符号来实现。
例：

object Test01 {
  def main(args: Array[String]): Unit = {
    var ann1 = new Animals("zs", "18")
    var ann2 = new Animals("zs", 18)
  }
}
case class Animals[T, S <: Comparable[S]](var name: T, var age: S)

此时如果在[T, S <: Comparable[S]]使用<:的话，在运行的时候会报错

因为：在类型变量界定的使用，默认的只能界定的类的是继承体系中的一员才成立，如果是使用隐式转换的方式默认不成立。上面代码：String类继承了Comparable，但是Int没有继承Comparable，只是隐式的将Int转换成了RichInt，RichInt继承了Comparable，所以此处出现了错误。
如果想隐式转换也可以通过泛型的话可以：

object Test01 {
  def main(args: Array[String]): Unit = {
    var ann1 = new Animals("zs", "18")
    var ann2 = new Animals("zs", 18)
  }
}
case class Animals[T, S <% Comparable[S]](var name: T, var age: 

利用<%号对泛型 S 进行限定，它的意思是 S 可以是 Comparable 类继承层次结构中实现了 Comparable 接口的类，也可以是能够经过隐式转换得到的实现了 Comparable 接口的类。
 

 3. scala上界下界

  在指定泛型类型时，有时需要界定泛型类型的范围，而不是接收任意类型。比如，要求某个 泛型类型，必须是某个类的子类，这样在程序中就可以放心的调用父类的方法，程序才能正 常的使用与运行。此时，就可以使用上下边界 Bounds 的特性； Scala 的上下边界特性允许泛型类型是某个类的子类，或者是某个类的父类。
   U>:T这是类型下界的定义,也就是 U 必须是类型 T 的父类(或本身，自己也可以认为是自己的父 类)。
   S<:T这是类型上界的定义，也就是 S 必须是类型 T 的子类（或本身，自己也可以认为是自己的子 类)。

上界：

class Generic2{
//指定上界，T必须是Comparable的子类或者是Comparable
def compare[T<:Comparable[T]] (first:T,second:T) ={
  }
}

下界：

class Generic3{
//指定下界，T必须是Comparable的父类或者是Comparable
def compare[T>:Comparable[T]] (first:T,second:T) ={
  }
}

 4. scala逆变和逆变

• 协变
   协变定义形式如：trait List[+T]{}
   当类型 B 是类型 A 的子类型时，则 List[B]也可以认为是 List[A}的子类型，即 List[B]可以泛化 为 List[A]。也就是被参数化类型的泛化方向与参数类型的方向是一致的，所以称为协变 （covariance）
  
  例：

  object Test01 {
  def main(args: Array[String]): Unit = {
  var list1:MyList[Person]=new MyList(new Person)
  var list2:MyList[Son]=new MyList(new Son)
  list1=list2
  }
  }
  class Person
  class Son extends Person
  class MyList[+T](val value:T)

  这种方式，在list中只能将子类转化成为父类的list，如果在转变之后，这个list中也只能存放子类的类型对象。协变的性质：输入的类型必须是 Son 的超类。

• 逆变
   逆变定义形式如：trait List[-T]{}
   当类型 B 是类型 A 的子类型，则 Queue[A]反过来可以认为是 Queue[B}的子类型。也就是被参数化类型的泛化方向与参数类型的方向是相反的，所以称为逆变（contravariance）。
  

• 总结
  • 协变（covariant），如果它保持了子类型序关系≦。该序关系是：子类型≦基类型。
  • 逆变（contravariant），如果它逆转了子类型序关系。
  • 不变（invariant），如果上述两种均不适用。