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

//案例: 泛型方法演示.
//細節(jié): 泛型方法在調用方法的時候 明確具體的數(shù)據(jù)類型.
object ClassDemo01 {
  //需求: 用一個方法來獲取任意類型數(shù)組的中間的元素
  //思路一:不考慮泛型直接實現(xiàn)（基于Array[Int]實現(xiàn)）
  //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)

//案例: 泛型-演示泛型類的使用.
//泛型類: 在創(chuàng)建對象的時候, 明確具體的數(shù)據(jù)類型.
object ClassDemo02 {
  //1. 實現(xiàn)一個Pair泛型類
  //2. Pair類包含兩個字段，而且兩個字段的類型不固定
  class Pair[T](var a:T, var b:T)

  def main(args: Array[String]): Unit = {
    //3. 創(chuàng)建不同類型泛型類對象，并打印
    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[指定具體的數(shù)據(jù)類型] {
  //類中的成員
}

//案例: 演示泛型特質.
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參數(shù)，
  //限定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參數(shù)，
  //限定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]

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

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

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

    //演示協(xié)變
    val t3:Temp2[Sub] = new Temp2[Sub]
    val t4:Temp2[Super] = t3          //不報錯, 因為協(xié)變是: 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]是父類型.
  }
}