23泛型

泛型

//泛型类
case class Point[T](val x:T,val y:T){
  def fun():T=x
}


object Demo1 {
  def main(args: Array[String]): Unit = {
    val p =Point[Int](1,2)
    val x: Int = p.x
    val i: Int = p.fun()
    
    val j: Int = fun2[Int](1)
    //可以推导
    val k: Int = fun2(1)
  }
  
  //泛型方法
  def fun2[T](x:T)=x
}

指定上下界，视图绑定

object Demo2 {
  def main(args: Array[String]): Unit = {
    println(compare[BigInt](1,2))

  }

  //泛型指定上界
  //传入类型是Ordered的子类
  def compare[T <: Ordered[T]](x:T,y:T)={
    if (x < y) x
    else y
  }
}

abstract class Animal{
  val name:String
}

abstract class Pet extends Animal{

}

class Dog extends Pet{
  override val name:String = "dog"
}
class Cat extends Pet{
  override val name:String = "cat"
}

object demo3 {
  def main(args: Array[String]): Unit = {
    showName(new Dog)
    showName(new Dog)
    getPet()


    
    println(max[Int](1, 2))

  }

  //泛型指定上界
  //传入类型是Ordered的子类
  def showName[T <:Pet](x:T)={
    println(x.name)
  }

  //指定下界
  //一般指定返回值
  def getPet[T >:Pet]():Pet={
     new Dog
  }

  //视图绑定
  //比如这里Int没有继承Ordered,但是存在隐式转换RichInt继承Ordered
  //所以把Int转换成RichInt
  def max[T <% Ordered[T]](x:T,y:T): Unit ={
    if (x < y) x
    else y
  }
}

不变，协变，逆变

class MyList[T]

class Father

class Son extends Father

object Demo5 {
  def main(args: Array[String]): Unit = {
    val a: Father = new Son

    var fList: MyList[Father] = new MyList[Father]
    var sList: MyList[Son] = new MyList[Son]
    
    //不变 默认
    //不行，子类型的泛型对象，不能赋值给父类型的泛型对象
    //fList =sList
    
    //协变
    //但是如果泛型对象是 MyList[+T] 就可以了 
    //fList=sList
    //适用于参数位置
    
    //逆变
    //但是如果泛型对象是 MyList[-T] 就可以了 
    //赋值给子类型用
    //sList=fList
    //适用于返回值位置
  }


}