Scala learning -- six uses of generics [t]

package com.dtspark.scala.basics
/**
 * 1,scala Classes and methods of 、 Functions can be generic .
 * 
 * 2, The definition of type boundary is divided into upper boundary and lower boundary （ Limit classes ）
 *  Upper boundary ： The type that expresses generics must be " Some kind of " Or some kind of " Subclass ", The grammar is “<:”,
 *  Lower boundary ： The type that expresses generics must be " Some kind of " Or some kind of " Parent class ", The grammar is “>:”,
 * 
 * 3, "<%" :view bounds Can make some mysterious transformation , Convert your type into the target type without consciousness ,
 *  In fact, you can think view bounds It is the strengthening and supplement of the upper and lower boundaries , The grammar is ："<%", Want to use implicit Make implicit conversions （ See the example below ）
 * 
 * 4,"T:classTag": Equivalent to dynamic type , What type you pass in when using is what type ,（spark The compilation and operation of the program are distinguished Driver and Executor Of , The complete type information is only known at runtime ）
 *  The grammar is ："[T:ClassTag]"
 *
 * 5, Contravariant and covariant ：-T and +T（ Here are specific examples ）+T You can pass in its subclasses and itself （ And inheritance relationship one to ）-T You can pass in its parent class and itself （ Contrary to inheritance ）,
 * 
 * 6,"T:Ordering" : It means that you will T become Ordering[T], You can directly use its method to compare the size , It can complete sorting and other work 
 */
class Person(val name:String){
  def talk(person:Person){
    println(this.name+" speak to "+person.name)
  }
}
class Worker(name:String)extends Person(name)
class Dog(val name:String)
// Note that generics use []
class Club[T<:Person](p1:T,p2:T){
    //"<:" Must be person or person Subclasses of 
  def comminicate = p1.talk(p2)
}
class Club2[T<%Person](p1:T,p2:T){
  def comminicate = p1.talk(p2)
}
class Engineer
class Expert extends Engineer
// If it is +T, When the specified type is a certain class , Pass in its subclasses or itself 
// If it is -T, When the specified type is a certain class , Pass in its parent class or itself 
class Meeting[+T]// You can pass in T or T Subclasses of 
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 HelloScalaTypeSystem {
  def main(args: Array[String]): Unit = {
     val p= new Person("Spark")
     val w= new Worker("Scala")
     new Club(p,w).comminicate
//"<%" Liezi 
     // It just provides a conversion method , In case of <% Will call to see dog Whether it has been converted .
     implicit def dog2Person(dog:Dog)=new Person(dog.name)
     val d = new Dog("dahuang")
     // Note that you must cast ,implicit Although it will dog Implicitly convert to person,
     // But it's actually object erasure , Turned into object, So we have to force the type to be converted to person Only after that can we use 
     // use [person] Coercive transformation 
     new Club2[Person](p,d).comminicate
 //-T +T Example , Below participateMeeting Method specifies the specific generic 
     val p1=new Meeting[Engineer]
     val p2=new Meeting[Expert]
     participateMeeting(p1)
     participateMeeting(p2)
 // T:Ordering  Example  
     println(new Maximum(3,5).bigger)
     println(new Maximum("Scala","Java").bigger)
  }
  // Here you specify what the incoming generic is 
  def participateMeeting(meeting:Meeting[Engineer])=  println("welcome")
}

   
    

T:ClassTag Example

Command line code ：

scala> import scala.reflect.ClassTag
import scala.reflect.ClassTag
scala> def mkArray[T: ClassTag](elems: T*) = Array[T](elems: _*)
mkArray: [T](elems: T*)(implicit evidence$1: scala.reflect.ClassTag[T])Array[T]
scala> mkArray(1,2,3)
res1: Array[Int] = Array(1, 2, 3)
scala> mkArray("ss","dd")
res2: Array[String] = Array(ss, dd)