Java Scala泛型(泛型方法,泛型類,泛型特質,上下界,協變、逆變、非變)

def 方法名[泛型名稱](..) = {
    //...
}

//案例: 泛型方法演示.
//細節: 泛型方法在呼叫方法的時候 明確具體的資料型別.
object ClassDemo01 {
  //需求: 用一個方法來獲取任意型別陣列的中間的元素
  //思路一:不考慮泛型直接實現（基於Array[Int]實現）
  //def getMiddleElement(arr: Array[Int]) = arr(arr.length / 2)

  //思路二: 加入泛型支援
  def getMiddleElement[T](arr: Array[T]) = arr(arr.length / 2)

  def main(args: Array[String]): Unit = {
      //呼叫方法
      println(getMiddleElement(Array(1, 2, 3, 4, 5)))

      println(getMiddleElement(Array("a", "b", "c")))
  }
}

class 類[T](val 變數名: T)

//案例: 泛型-演示泛型類的使用.
//泛型類: 在建立物件的時候, 明確具體的資料型別.
object ClassDemo02 {
  //1. 實現一個Pair泛型類
  //2. Pair類包含兩個欄位，而且兩個欄位的型別不固定
  class Pair[T](var a:T, var b:T)

  def main(args: Array[String]): Unit = {
    //3. 建立不同型別泛型類物件，並列印
    var p1 = new Pair[Int](10, 20)
    println(p1.a, p1.b)

    var p2 = new Pair[String]("abc", "bcd")
    println(p2.a, p2.b)
  }
}

trait 特質A[T] {
  //特質中的成員
}

class 類B extends 特質A[指定具體的資料型別] {
  //類中的成員
}

//案例: 演示泛型特質.
object ClassDemo03 {
  //1. 定義泛型特質Logger, 該類有一個a變數和show()方法, 都是用Logger特質的泛型.
  trait Logger[T] {
    //定義變數
    val a:T

    //定義方法.
    def show(b:T) = println(b)
  }

  //2. 定義單例物件ConsoleLogger, 繼承Logger特質.
  object ConsoleLogger extends Logger[String]{
    override val a: String = "張三"
  }

  //main方法, 作為程式的主入口.
  def main(args: Array[String]): Unit = {
    //3. 列印單例物件ConsoleLogger中的成員.
    println(ConsoleLogger.a)
    ConsoleLogger.show("10")
  }
}

[T <: 型別]

//案例: 演示泛型的上下界之  上界.
object ClassDemo04 {
  //1. 定義一個Person類
  class Person

  //2. 定義一個Student類，繼承Person類
  class Student extends Person

  //3. 定義一個demo泛型方法，該方法接收一個Array引數，
  //限定demo方法的Array元素型別只能是Person或者Person的子類
  def demo[T <: Person](arr: Array[T]) = println(arr)

  def main(args: Array[String]): Unit = {
    //4. 測試呼叫demo，傳入不同元素型別的Array
    //demo(Array(1, 2, 3))          //這個會報錯, 因為只能傳入Person或者它的子型別.

    demo(Array(new Person()))
    demo(Array(new Student()))
  }
}

[T >: 型別]

//案例: 演示泛型的上下界之 下界.
//如果你在設定泛型的時候, 涉及到既有上界, 又有下界, 一定是: 下界在前, 上界在後.
object ClassDemo05 {
  //1. 定義一個Person類
  class Person
  //2. 定義一個Policeman類，繼承Person類
  class Policeman extends Person
  //3. 定義一個Superman類，繼承Policeman類
  class Superman extends Policeman

  //4. 定義一個demo泛型方法，該方法接收一個Array引數，
  //限定demo方法的Array元素型別只能是Person、Policeman
  //          下界          上界
  def demo[T >: Policeman <: Policeman](arr: Array[T]) = println(arr)

  def main(args: Array[String]): Unit = {
    //5. 測試呼叫demo，傳入不同元素型別的Array
    //demo(Array(new Person))
    demo(Array(new Policeman))
    //demo(Array(new Superman))     //會報錯, 因為只能傳入: Policeman類獲取它的父類別型, 而Superman是Policeman的子型別, 所以不行.
  }
}

class Pair[T]{}

class Pair[+T]

class Pair[-T]

//案例: 演示非變, 協變, 逆變.
object ClassDemo06 {
  //1. 定義一個Super類、以及一個Sub類繼承自Super類
  class Super               //父類別
  class Sub extends Super   //子類

  //2. 使用協變、逆變、非變分別定義三個泛型類
  class Temp1[T]            //非變
  class Temp2[+T]           //協變
  class Temp3[-T]           //逆變.

  def main(args: Array[String]): Unit = {
    //3. 分別建立泛型類來演示協變、逆變、非變
    //演示非變.
    val t1:Temp1[Sub] = new Temp1[Sub]
    //val t2:Temp1[Super] = t1          //編譯報錯, 因為非變是: Super和Sub有父子類關係, 但是Temp1[Super] 和 Temp1[Sub]之間沒有關係.

    //演示協變
    val t3:Temp2[Sub] = new Temp2[Sub]
    val t4:Temp2[Super] = t3          //不報錯, 因為協變是: Super和Sub有父子類關係, 所以Temp2[Super] 和 Temp2[Sub]之間也有父子關係.
                                      //Temp2[Super]是父類別型,   Temp2[Sub]是子型別.

    //演示逆變
    val t5:Temp3[Super]  = new Temp3[Super]
    val t6:Temp3[Sub] = t5          //不報錯, 因為逆變是:  Super和Sub有父子類關係, 所以Temp3[Super] 和 Temp3[Sub]之間也有子父關係.
                                    //Temp3[Super]是子型別,   Temp3[Sub]是父類別型.
  }
}