scala中的泛型

对于一个带类型参数的类型，比如 List[T]，如果对A及其子类型B，满足 List[B]也符合 List[A]的子类型，那么就称为covariance(协变)，如果 List[A]是 List[B]的子类型，即与原来的父子关系正相反，则称为contravariance(逆变)

package kang
/*
 * 1.scala中类，函数，方法都可以是泛型，
 * 2.关于类型边界，分为上边界和下边界
 * 		（1）T <: Human 意思是Human或Human的子类，对上边界进行限定
 * 		（2）T >: Human 意思是Human或Human的父类，对下边界进行限定
 * 3.view bounds 隐式类型转换，不需要继承，通过“implicit”关键字来实现
 * 		（1）T <% Human 
 * 		（2）T >% Human 
 * 4. T : ClassTag也是一种类型转换系统，只是在编译的时候类型信息不足，需要在Jvm运行时
 * 		获得完整的的类型信息
 * 5.逆变和协变： -T和+T
 * 6.context bounds  T:Ordering这种方式必须能编译Ordering[T]的方式
*/
class Animal[T](val species:T){
  def getSpecie:T=species
}


class Human(val name:String){
  def talk(human:Human){
    println(this.name+ " : "+human.name)
  }
}
class Custom( name:String) extends Human(name)
class Boss(val name:String)
// T <: Human 意思是Human或Human的子类，对上边界进行限定
// T >: Human 意思是Human或Human的父类，对下边界进行限定
class Shop[T <: Human](p1:T,p2:T){
  def comunicate=p1.talk(p2)
}
//隐式类型转换
class Shop2[T <% Human](p1:T,p2:T){
  def comunicate=p1.talk(p2)
}


class GrandFather
class Father extends GrandFather
class Son extends Father
class Meeting[+T]
class Meeting2[-T]


class Maximum[T:Ordering](val x:T ,val y:T){
  def bigger(implicit ord:Ordering[T]) = {
    if(ord.compare(x,y) > 0) x else y
  }
}

object Scala_genericity {
  def main(args: Array[String]): Unit = {
    var human=new Human("人类")
    var custom=new Custom("顾客")
    var boss=new Boss("老板")
    new Shop(human,custom) .comunicate
    
    implicit def bossToHuman(boss:Boss)=new Human(boss.name)
    new Shop2[Human](boss,custom) .comunicate
    
    var meet_1_1 = new Meeting[GrandFather]
    var meet_1_2 = new Meeting[Father]
    var meet_1_3 = new Meeting[Son]
    var meet_2_1 = new Meeting2[GrandFather]
    var meet_2_2 = new Meeting2[Father]
    var meet_2_3 = new Meeting2[Son]
    
    //只能传进去类型为Father及其子类的Meeting
    meet_1(meet_1_2)
    meet_1(meet_1_3)
    //只能传进去类型为Father及其父类的Meeting
    meet_2(meet_2_1)
    meet_2(meet_2_2)
    
    var bigger=new Maximum(2,3).bigger
    println(bigger)
  }
  
  def meet_1(meeting:Meeting[Father]){//只能传进去类型为Father及其子类的Meeting
    println("hello")
  }
  def meet_2(meeting:Meeting2[Father]){//只能传进去类型为Father及其父类的Meeting
    println("hello")
  }
}