class Triple[F, S, T](val first: F, val second: S, val third: T) //定义一个泛型类
object Hello_Type_Parameterization {
def main(args: Array[String]) {
val triple = new Triple("Spark", 3, 3.1415) //这里没指定类型，是因为Scala可以进行类型推导
val bigData = new Triple[String, String, Char]("Spark", "Hadoop", 'R')
def getData[T](list : List[T]) = list(list.length / 2) //定义泛型方法
println(getData(List("Spark", "Hadoop", 'R')))
val f = getData[Int] _
println(f(List(1,2,3,4,5,6)))
val queue = Queue(1,2,3,4,5)
val queue_appended = queue enqueue 6
println("queue : " + queue + " " + "queue_appended : " + queue_appended)
}
}
泛型边界Bounds
//class Pair[T](val first : T, val second : T)
class Pair[T <: Comparable[T]](val first : T,val second : T){ //T必须是Comparable[T]的子类，这是它的上界
def bigger = if(first.compareTo(second) > 0)first else second
}
class Pair_Lower_Bound[T](val first:T,val second:T){
def replaceFirst[R >: T](newFirst:R)= new Pair_Lower_Bound[R](newFirst,second) //R是T的父类，T是R的下界，反过来，R是T的上界
}
object Typy_Variables_Bounds {
def main(args: Array[String]){
val pair = new Pair("Spark", "Hadoop")
println(pair.bigger)
}
}
视图界定：在类型变量上界无法满足功能时，使用视图界定，视图界定通过隐式转换可以把T转换为Comparable[T]的子类
//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){ //视图界定，对于不是Comparable[T]的T，隐式转换T的类型，如，将Int隐式转换为RichInt，RichInt实现了Comparable[Int]
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，如果没有试图界定，这里会编译出错，因为Int没有实现Comparable[Int]
println(pairInt.bigger)
val pair_Better_String = new Pair_Better("Java", "Scala") //String -> RichString，RichString是Ordered[String]的子类型
println(pair_Better_String.bigger)
val pair_Better_Int = new Pair_Better(20, 12)
println(pair_Better_Int.bigger)
}
}
上下文界定
class Pair_Ordering[T : Ordering] (val first : T, val second : T){ //存在一个Ordering[T]的隐式值。first、second也是Ordering[T]类型的
def bigger(implicit ordered: Ordering[T]) = { //该ordered对象会实现compare方法，因为在Ordering中compare方法是抽象的
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)//bigger方法会隐式地传入参数ordered
val pairInt = new Pair_Ordering(3, 5)
println(pairInt.bigger)
}
}
Scala多重界定
T >: A <: B 同时拥有上界跟下界，下界是A，下界是B，A是B的子类型。语法要求下界必须在前，上界必须在后。
但是不能有多个上界或多个下界（语法不允许），想要表达多个上界怎么办？使用with
T <: A with B T是A或者B的子类
T >: A with B A或者B是T的子类
T <% A <% B 视图界定，T既可以转换为A，并且也可以转换为B（隐式转换）
T : A : B 上下文界定，T同时满足存在A[T]隐式值和B[T]的隐式值
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") //多个上下文界定，必须同时存在M_A[Int]、M_B[Int]的隐式值
foo(2)
}
}
Scala类型约束
def main(args: Array[String]){
//A =:= B //表示A类型等同于B类型
//A <:< B //表示A类型是B类型的子类型
def rocky[T](i:T)(implicit ev: T <:< java.io.Serializable) {//要求T必须是Serializable的子类型
print("Life is short,you need spark!") }
rocky("Spark") //正确，String是Serializable的子类
rocky(100) //错误，Int不是Serializable的子类
}