对于一个带类型参数的类型,比如 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")
}
}