Scala（第十一章 泛型）

11.1 协变和逆变

1）语法

class MyList[+T]{ //协变
} 
class MyList[-T]{ //逆变
}
class MyList[T] //不变

   
   
     
     
     
     

   
   
     
     
     
     

      
      
      
      
1
      
      
      
      
2
      
      
      
      
3
      
      
      
      
4
      
      
      
      
5
     
     
     
     

2）说明

协变：Son 是 Father 的子类，则 MyList[Son] 也作为 MyList[Father]的“子类”。
逆变：Son 是 Father 的子类，则 MyList[Son]作为 MyList[Father]的“父类”。
不变：Son 是 Father 的子类，则 MyList[Father]与 MyList[Son]“无父子关系”。

   
   
     
     
     
     

   
   
     
     
     
     

      
      
      
      
1
      
      
      
      
2
      
      
      
      
3
     
     
     
     

3）实操

//泛型模板
//class MyList{}
//不变
//class MyList[T]{}
//协变
//class MyList[+T]{}
//逆变
//class MyList[-T]{}
class Parent{}
class Child extends Parent{}
class SubChild extends Child{}
object Scala_TestGeneric {
 def main(args: Array[String]): Unit = {
 //var s:MyList[Child] = new MyList[SubChild]

}
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17

11.2 泛型上下限

1）语法

Class PersonList[T <: Person]{ //泛型上限
}
Class PersonList[T >: Person]{ //泛型下限
}

 
 
   
   
   
   

 
 
   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
   
   
   
   

2）说明

泛型的上下限的作用是对传入的泛型进行限定。

3）实操

class Parent{}
class Child extends Parent{}
class SubChild extends Child{}
object Scala_TestGeneric {
 def main(args: Array[String]): Unit = {
 //test(classOf[SubChild])
 //test[Child](new SubChild)
 }
 //泛型通配符之上限
 //def test[A <: Child](a:Class[A]): Unit ={
 // println(a)
 //}
 //泛型通配符之下限
 //def test[A >: Child](a:Class[A]): Unit ={
 // println(a)
 //}
 //泛型通配符之下限 形式扩展
 def test[A >: Child](a:A): Unit ={
 println(a.getClass.getName)
 }
}

 
 
   
   
   
   

 
 
   
   
   
   

  
  
 
 
   
   
   
   
 
 
   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
    
    
    
    
10
    
    
    
    
11
    
    
    
    
12
    
    
    
    
13
    
    
    
    
14
    
    
    
    
15
    
    
    
    
16
    
    
    
    
17
    
    
    
    
18
    
    
    
    
19
    
    
    
    
20
    
    
    
    
21
   
   
   
   

11.3 上下文限定

1）语法

def f[A : B](a: A) = println(a) //等同于 def f[A](a:A)(implicit arg:B[A])=println(a)

 
 
   
   
   
   

 
 
   
   
   
   

    
    
    
    
1
   
   
   
   

2）说明

上下文限定是将泛型和隐式转换的结合产物，以下两者功能相同，使用上下文限定[A : Ordering]之后，方法内无法使用隐式参数名调用隐式参数，需要通过 implicitly[Ordering[A]]获取隐式变量，如果此时无法查找到对应类型的隐式变量，会发生出错误

implicit val x = 1
val y = implicitly[Int]
val z = implicitly[Double]

 
 
   
   
   
   

 
 
   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
   
   
   
   

3）实操

def f[A:Ordering](a:A,b:A) =implicitly[Ordering[A]].compare(a,b)
def f[A](a: A, b: A)(implicit ord: Ordering[A]) = ord.compare(a, b)

 
 
   
   
   
   

 
 
   
   
   
   

    
    
    
    
1
    
    
    
    
2