Scala基础11——第11章：泛型

第11章 泛型

​

// Array[String] 使用了泛型为String的Array
def main(args:Array[String]):Unit={}

为什么要用泛型：如果使用Any的话，就需要进行强转，强转可能会出现一些意外情况

11.1 协变和逆变

class MyList[+T] // 协变

class MyList[-T] // 逆变

class MyList[T] // 不变

协变： Son是Father的子类，则MyList[Son]也是MyList[Father]的子类

协变： Son是Father的子类，则MyList[Son]也是MyList[Father]的父类

不变： Son是Father的子类，则MyList[Son] ， MyList[Father]没有父子关系

object Test03{
    def main(args:Array[String]):Unit={
    	// 1 协变和逆变
        val child:Child = new Child 
        val child:Parent = new Child
        
        
        // val childList:MyCollection[Parent] = new MyCollection[Child] // 定义为不变，
        
        val childList:MyCollection2[Parent] = new MyCollection2[Child] // 定义为协变
        
        val childList2:MyCollection3[Child] = new MyCollection3[Parent] // 定义为协变
    }
    
    
}

class Parent{}
class Child extends Parent{}
class SubChild extends Child{}

class MyCollection[E] {}
class MyCollection2[+E] {}
class MyCollection3[-E] {}

11.2 泛型上下限

基本语法

class PersonList[ T <: Person ] // 泛型上限
// 可以是person的子类，或者自身

class PersonList[ T >: Person ] // 泛型下限
// 可以是person的父类，或者自身

object Test03{
    def main(args:Array[String]):Unit={
        
        // 上下限
        def test[A <: Child](a:A): Unit={
            println(a.getClass.getName)
        }
        
        // test[Parent](new Child) //!!!报错，超过上限
        test[Child](new Child)
        test[Child](new SubChild)
        
        
    }    
}

class Parent{}
class Child extends Parent{}
class SubChild extends Child{}

11.3 上下文限定

基本语法

def f[A:B](a:A) = println(a)
// 等价于
def f[A](a:A)(implicit arg:B[A]) = println(a)
// 把B作为隐式参数，且参数的泛型是A