Scala (十一) --------- 泛型

谁借莪１个温暖的怀抱￠ 2024-04-07 10:12 5阅读 0赞

#### 目录 ####

*  一、协变和逆变
 *  二、泛型上下限
 *  三、上下文限定

--------------------

## 一、协变和逆变 ##

**语法**

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

**说明**

协变：Son 是 Father 的子类，则 `MyList[Son]` 也作为 `MyList[Father]` 的子类。

逆变：Son 是 Father 的子类，则 `MyList[Son]` 作为 `MyList[Father]`的父类。

不变：Son 是 Father 的子类，则 `MyList[Father]`与 `MyList[Son]` 无父子关系。

**实操**

//泛型模板
    //class MyList<T>{}
    //不变
    //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]
    	
    	}
    }

## 二、泛型上下限 ##

**语法**

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

**说明**

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

**实操**

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)
    	}
    }

## 三、上下文限定 ##

**语法**

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

**说明**

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

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

**实操**

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)