點選(此處)摺疊或開啟

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的子類
}

Scala的泛型

相關文章