Scala进阶源码实战之六——类型变量

View Bounds 视图界定

package com.dt.scala.type_parameterization

//class Pair_NotPerfect[T <: Comparable[T]](val first : T,val second : T){
//  def bigger = if(first.compareTo(second) > 0)first else second  
//}
//  <% 学术名称就是视图界定
class Pair_NotPerfect[T <% Comparable[T]](val first : T,val second : T){
    def bigger = if(first.compareTo(second) > 0)first else second  
}

class Pair_Better[T <% Ordered[T]](val first : T,val second : T){
    def bigger = if(first > second)first else second  
}



object View_Bounds {

  def main(args: Array[String]) {


    val pair = new Pair_NotPerfect("Spark", "Hadoop")
    println(pair.bigger)

    val pairInt = new Pair_NotPerfect(3, 5) //Int -> RichInt
    println(pairInt.bigger)

    val pair_Better_String = new Pair_Better("Java", "Scala") //String -> RichString
    println(pair_Better_String.bigger)

    val pair_Better_Int = new Pair_Better(20, 12)
    println(pair_Better_Int.bigger)


  }

}

Context Bounds

package com.dt.scala.type_parameterization

import java.util.Comparator


class Pair_Ordering[T : Ordering] (val first : T, val second : T){
  def bigger(implicit ordered: Ordering[T]) = {
    if (ordered.compare(first, second) > 0) first else second
  }
}

object Context_Bounds {

  def main(args: Array[String]) {

    val pair = new Pair_Ordering("Spark", "Hadoop")
    println(pair.bigger)

    val pairInt = new Pair_Ordering(3, 5)
    println(pairInt.bigger)

  }

}

ClassTag 、Manifest、ClassManifest、TypeTag

package type_paraments
import scala.reflect.ClassTag
class A[T]
object classtag {
  println("Welcome to the Scala worksheet")       //> Welcome to the Scala worksheet

  def arrayMake[T : Manifest](first : T, second : T) = {
      val r = new Array[T](2); r(0) = first; r(1) = second; r                //看下面已经生成了隐式值
    }                                             //> arrayMake: [T](first: T, second: T)(implicit evidence$3: Manifest[T])Array[T
                                                  //| ]
   arrayMake(1,2).foreach(println)                //> 1
                                                  //| 2

   //实际中用的最多的是ClassTag 可以代替Manifest
   //运行时将泛型擦除，通过上下文推断
   def mkArray[T : ClassTag](elems: T*) = Array[T](elems: _*)
                                                  //> mkArray: [T](elems: T*)(implicit evidence$4: scala.reflect.ClassTag[T])Array
                                                  //| [T]
   mkArray(42, 13).foreach(println)               //> 42
                                                  //| 13
   mkArray("Japan","Brazil","Germany").foreach(println)
                                                  //> Japan
                                                  //| Brazil
                                                  //| Germany


    def manif[T](x: List[T])(implicit m: Manifest[T]) = {
        if (m <:< manifest[String])
          println("List strings")
        else
          println("Some other type")
    }                                             //> manif: [T](x: List[T])(implicit m: Manifest[T])Unit
    manif(List("Spark", "Hadoop"))            //> List strings
    manif(List(1, 2))                         //> Some other type
    manif(List("Scala", 3))                   //> Some other type

    val m = manifest[A[String]]                   //> m  : Manifest[type_paraments.A[String]] = type_paraments.A[java.lang.String]
                                                  //| 
    println(m)                                //> type_paraments.A[java.lang.String]
    val cm = classManifest[A[String]]         //> cm  : ClassManifest[type_paraments.A[String]] = type_paraments.A[java.lang.S
                                                  //| tring]
    println(cm)                               //> type_paraments.A[java.lang.String]
}  

多重界定

class M_A[T]
class M_B[T]

object Multiple_Bounds {

  def main(args: Array[String]) {
    implicit val a = new M_A[Int]
    implicit val b = new M_B[Int]
    def foo[ T : M_A : M_B ](i:T) = println("OK")
    foo(2) 

  }

}

类型约束

    def rocky[T](i:T)(implicit ev: T <:< java.io.Serializable) {
      print("Life is short,you need spark!") }
    rocky("Spark")

Variance
spark 中用的并不多，作为了解