Scala 語言學習之泛型（7）

==> 泛型類

        ---> T 能夠表明任意類型

class Person[T]{
  private var name:T = _

  def setName(name:T) = {this.name = name}
  def getName():T = {this.name}
}

// ***********測試*****************
object Person{
  def main(args:Array[String]):Unit = {
    var p = new Person[String]()
    p.setName("hello")
    println(p.getName())
  }
}

==> 泛型函數

        ---> 類型參數放在方法名以後

//* 泛型函數
// 建立一個固定類型的數組
// 普通函數
def mkInt(elems:Int*) = Array[Int](elems:_*)
def mkString(str:String*) = "mkString"

// 使用泛型函數，能夠接收任意類型
def mkArray[T:ClassTag](elems:T*) = Array[T](elems:_*)

// ***********測試*****************
// 普通函數只能傳入相對應類型的參數
mkInt(1,2,3)
mkString("hello", "world")

// 泛型函數能夠傳入任意類型的參數
mkArray(11.26,665, 84, "hello")

==> 類型的上界和下界（Upper Bounds 和 Lower Bounds）

        ---> 用來定義泛型變量的範圍 ：  

        ---> S <: T  (上界)        S 必須是 T 類型的子類或類自己

class Person1{
  def gender() = {println("gender")}
}

class Man extends Person1{
  override def gender() = {println("man")}
}

class Women extends Person1{
  override def gender() = {println("women")}

object UpperBoundsAndLowerBounds {
  // 定義一個泛型函數，經過上界的方式指定泛型的範圍必須是 Person1 的子類或者Person1 類，並調用類中的 gender 方法
  def getGender[T <: Person1](g:T) = {g.gender()}

  def main(args:Array[String]): Unit = {
    // 建立一個Person1 對象 ，調用getGender 方法調用 Personal 中的 gender 方法
    var p:Person1 = new Person1
    getGender(p)

    // 建立一個 Man 對象 ，經過 getGender 方法調用Man 類中的 gender 方法
    var m = new Man
    getGender(m)
  }

}

        ---> U >: T(下界)        U 必須是 T 類型的父類或類自己，此處不做示例，與上面例子相似，只是傳入 getGender 方法中的參數必須是 Person1 類或其父類的對象

==> 視圖界定    <%

        ---> 與類型的上界類似，可是比類型的上界適用範圍更廣，除了全部的子類與類自己，它還容許經過隱式轉換獲得的類型

def int2String[T <% String](x:T, y:T) = {
  println(x + "*****" + y)
}

// ***********測試*****************
int2String("hello", "world")
implicit def int2String1(n:Int):String = {n.toString}
int2String(100, 120)

==> 協變和逆變

        ---> 協變： 泛型變量的值能夠是子類或類自己     在類型參數前加一個 「+」 符號    子類轉換爲父類

//* 協變和逆變   在類型的前面加入 +號，就可使類的特徵變爲協變了
// 將子類對象轉換爲父類對象稱爲協變 +
// 將父類對象轉換爲子類對象稱爲逆變 -
package demo1{
  // 父類
  class Animal{}
  // 子類
  class Bird extends Animal
  class Sparrow extends Bird
  
  // 吃東西的類      協變
  class EatSomethings[+T](t:T){}

  // ***********測試*****************
  object Demo1{

    def main(args:Array[String]): Unit={
      // 建立一個吃東西的對象
      var c1:EatSomethings[Sparrow] = new EatSomethings[Sparrow](new Sparrow)

      var c2:EatSomethings[Animal] = c1
    }
  }
}

        ---> 逆變： 泛型變量的值能夠是父類或類自己    在類型參數前加一個 「 - 」 符號    父類轉換爲子類    例：省略

==> 隱式轉換函數    

        ---> 以關鍵字  implicit   申明

        ---> 單個參數

class Fruit(name:String){
  def getFruitName():String = {name}
}

class Monkey(f:Fruit){
  def say() = {println("Monkey like " + f.getFruitName()) }
}

// ***********測試*****************
object ImplicitDemo {
  def main(args:Array[String]):Unit = {
    var f:Fruit = new Fruit("bnanan")

    // 調用 fruit 的方法，但願 Monkey這個say 方法來實現
    // 須要將 fruit 的對象轉換爲 monkey 對象， 即定義一個隱匿轉換函數
    implicit def fruit2Monkey(f:Fruit):Monkey = {new Monkey(f)}     // 將 fruit 對象轉換爲 Monkey 對象
    // 調用Monkey中的 say 方法
    f.say()
  }
}

==> 隱式參數    使用 implicit 關鍵字申明的函數參數

        ---> 可使用隱式參數進行類型轉換

// 隱式參數
def testParam(implicit name:String) = {println("The value is " + name)}
implicit val name:String = "這是一個隱式值"

// ***********測試*****************
testParam
//---------------------------------------------------------------

// 帶隱式參數的泛型函數
// Ordered[T] 使類型可排序，
//     原型：def smaller
// (implicit order:T      =>    Ordered[T])
def smaller[T](a:T, b:T)(implicit order:T => Ordered[T]) = if(order(a) < b) a else b

// ***********測試*****************
smaller(100, 56)
smaller("hello", "hi")

==> 隱式類    對類  增長 implicit 限定 的類，其主要做用就是對類的功能加強

        ---> 編寫一個隱式類，使類實現更多的功能

object testImplicit {

  // 定義一個隱式類
  implicit class Calc(x:Int){
    def add(a:Int):Int = a + x
  }

  // ***********測試*****************
  def main(args:Array[String]):Unit = {
    println("兩個數字的和：" + 1.add(2))
  }
}

        ---> 程序過程分析：

                --- 當 1.add(2)時，scala 的編譯器不會報錯，在當前域中查找，有沒有 implicit 修飾的，同時能夠將 Int 做爲參數的構造器，而且具備 add 方法的類，經過查找，找到 Calc

                --- 利用隱式類 Calc 來執行 add 方法

==> 我的總結：

        ---> 經過泛型，可使咱們定義一個模具，就像蛋糕的模具，咱們能夠分別放入草莓，藍莓等不一樣的原料加工出不一樣口味的蛋糕來

        ---> 經過使用 上界，下界，視圖界定，協變，逆變，對泛型的範圍制定規則，使咱們能夠傳入的符合規則的參數

        ---> 隱式函數，隱式參數，隱式類，會在程序運行時首先被查找，如有符合 以 implicit 修飾的參數，函數以及類，先執行，而後才運行程序

若總結有誤，還請多多指教，謝謝！！！