有兴趣看视频

泛型方法

package tcode.chapter11
object $01_GenericMethod {
  /**
    * 泛型方法: def 方法名[T,U,](x:T):U = {..}
    */
  def main(args: Array[String]): Unit = {
    val arr = Array[Int](1,2,3)
    val arr2 = Array[String]("aa")
    println(getLength[String](arr2))
  }
  def getLength[T](arr:Array[T]):Int = {
    arr.length
  }
}

泛型类

package  tcode.chapter11
object $02_GenericClass {
  class Person[T,U](val name:T,val age:U){
    def getName():T = this.name
    def getAge():U = this.age
  }
  /**
    * 泛型类: class 类名[T,U,..](属性名:T,..){
    *
    *   def 方法名(y:U):T = {...}
    * }
    * @param args
    */
  def main(args: Array[String]): Unit = {
    val person = new Person[String,Int]("lisi",2)
    println(person.getAge())
  }
}

泛型逆变、协变

package tcode.chapter11
object $03_GenericChange {
  class B
  class C extends B
  //非变
  class Person1[T]
  //协变
  class Person2[+T]
  //逆变
  class Person3[-T]
  /**
    * 协变[+T]: 泛型之间是父子关系，通过泛型创建的对象之间继承了泛型的父子关系
    * 非变[T]: 泛型之间是父子关系，通过泛型创建的对象之间没有任何关系
    * 逆变[-T]: 泛型之间是父子关系，通过泛型创建的对象之间颠倒了泛型的父子关系
    *
    */
  def main(args: Array[String]): Unit = {
    var bs = List[B](new B,new B)
    var cs = List[C](new C,new C)
    bs = cs
    println(bs)
    //非变
    var bp = new Person1[B]
    var cp = new Person1[C]
    //
    //bp = cp
    //cp = bp
    //协变
    var bp2 = new Person2[B]
    var cp2 = new Person2[C]
    bp2 = cp2
    println(bp2)
    //逆变
    var bp3 = new Person3[B]
    var cp3 = new Person3[C]
    cp3 = bp3
    println(cp3)
  }
}

泛型上下限

package  tcode.chapter11
object $04_GenericLowUpper {
  class Parent
  class Sub1 extends Parent
  class Sub2 extends Sub1
  class Sub3 extends Sub2
  def m1[T<:Sub1](t:T): Unit ={
    println(t)
  }
  def m2[T>:Sub2](t:T): Unit ={
    println(t)
  }
  def m3[T>:Sub2<:Parent](t:T): Unit ={
    println(t)
  }
  /**
    * 上限:  T <:类型 代表T必须是指定类型或者是其子类
    * 下限:  T>:类型 代表T必须是指定类型或者是其父类
    * 如果需要同时写上下限,先写下限再写上限 T>:类型1<:类型2
    */
  def main(args: Array[String]): Unit = {
    m1(new Sub1)
    val s:Any = 1
    m2(s)
    m3(new Sub3)
  }
}

泛型上下文限定

package  tcode.chapter11
import scala.beans.BeanProperty
object $05_GenericContext {
  class Person[T](@BeanProperty var name:T)
  def m1[T](x:T)(implicit p:Person[T]) = {
    p.setName(x)
    println(p.getName)
  }
  def m2[T:Person](x:T) = {
    val person = implicitly[Person[T]]
    person.setName(x)
    println(person.getName)
  }
  /**
    * 泛型上下文:
    *   def 方法名[T:指定类型](..):返回值类型 = {..}
    *   等价于
    *   def 方法名[T](..)(implicit 参数名: 指定类型[T]):返回值类型 = {..}
    *
    */
  def main(args: Array[String]): Unit = {
    implicit val p:Person[String] = new Person[String]("")
    m1[String]("lisi")
    m2[String]("zhangsan")
  }
}