scala 系列之 18scala 泛型

22 泛型

泛型就是不確定的類型袜硫，可以在類或方法不確實傳入類型時使用箭阶，可以提高代碼的靈活性和復用性挤安；

scala中泛型的用法和java中差不多谚殊，但是會有一些自己獨特的語法；

泛型類：指定類可以接受任意類型參數(shù)蛤铜。

泛型方法：指定方法可以接受任意類型參數(shù)嫩絮。

22.1 泛型類基本用法

package day04
import day04.SexEnumObj.SexEnum
// 定義帶有泛型的抽象類
abstract class FXDemo[T](val t : T) {
  def printInfo():Unit
}
// 子類繼承父類，把泛型具體化成Int
class FXIntDemo[Int](t : Int) extends FXDemo[Int](t:Int){
  override def printInfo(): Unit = {
    println(s"FXIntDemo[Int](${t})")
  }
}
// 子類繼承父類围肥，把泛型具體化成String
class FXStringDemo[String](t : String) extends FXDemo[String](t:String){
  override def printInfo(): Unit = {
    println(s"FXIntDemo[String](${t})")
  }
}
// 定義帶有多泛型的類
class FXABCDemo[A, B, C](val a:A, val b:B, val c:C){
  override def toString: String = s"${a}, $剿干, ${c}"
}
// 定義sex的枚舉對象
object SexEnumObj extends Enumeration{
  // 定義枚舉類型（用于泛型）
  type SexEnum = Value
  // 定義枚舉值
  val boy, girl = Value
}
object FXDemo{
  def main(args: Array[String]): Unit = {
    val demo = new FXIntDemo[Int](100)
    demo.printInfo()
    val demo2 = new FXStringDemo[String]("xiaoming")
    demo2.printInfo()
    val demo3 = new FXABCDemo[String, Int, String]("xiaoming", 20, "boy")
    println(demo3)
    val demo4 = new FXABCDemo[String, Int, SexEnum]("xiaoming", 20, SexEnumObj.boy)
    println(demo4)
  }
}

22.2 泛型種類

[B <: A] UpperBound 上界，B類型的父類是A類型穆刻，左側(cè)的B的類型必須是A類型或者A類型的子類怨愤。

[B >: A] LowerBound 下界，B類型的子類是A類型蛹批，左側(cè)的B的類型必須是A類型或者A類型的父類撰洗。

[B <% A] ViewBound B類型轉(zhuǎn)換成A類型篮愉，需要一個隱式轉(zhuǎn)換函數(shù)。

[B : A] ContextBound 通過隱式轉(zhuǎn)換增加個 A[B] 類型差导。

[-A] 逆變试躏，通常作為參數(shù)類型，T是A的子類设褐。

[+B] 協(xié)變颠蕴，通常作為返回類型，T是B的父類助析。

22.2.1 UpperBound

UpperBound 用在泛型類或泛型方法上犀被，用于限制傳遞的參數(shù)必須是指定類型對象或其子類對象。

如果想實現(xiàn)兩個對象的比較外冀，需要該對象實現(xiàn)Comparable接口寡键。然后再配上泛型實現(xiàn)通用比較。

泛型繼承雪隧，java的用法

package javaday04;
public class UpperBoundDemo<T extends Comparable<T>> {
    // psvm
    public static void main(String[] args) {
        // Integer 實現(xiàn)了 Comparable接口西轩，創(chuàng)建對象時，約束通過
        UpperBoundDemo<Integer> demo1 = new UpperBoundDemo<Integer>();
        // Hainiu 沒實現(xiàn) Comparable接口脑沿，創(chuàng)建對象時藕畔，約束不通過
//        UpperBoundDemo<Hainiu> demo2 = new UpperBoundDemo<Hainiu>();
        // 約束通過
        UpperBoundDemo<HainiuComparable> demo3 = new UpperBoundDemo<HainiuComparable>();
    }
}
class Hainiu{}
class HainiuComparable implements Comparable<HainiuComparable>{
    public int compareTo(HainiuComparable o) {
        return 0;
    }
}

泛型繼承，scala用法

package day04
// 在類上定義泛型庄拇， new對象時就會約束
class UpperBoundDemo[T <: Comparable[T]](val t:T) {
}

object UpperBoundDemo{
  def main(args: Array[String]): Unit = {
    // 因為 Integer 是 Comparable 實現(xiàn)類注服，所以約束通過
    val demo = new UpperBoundDemo[Integer](100)
    println(demo.t)
   
    // 約束通過
    val demo2 = new UpperBoundDemo[HainiuComparable](new HainiuComparable())
  }
}

class HainiuComparable implements Comparable<HainiuComparable>{
    public int compareTo(HainiuComparable o) {
        return 0;
    }
}

22.2.2 LowerBound

LowerBound 用在泛型類或泛型方法上，用于限制傳遞的參數(shù)必須是指定類型對象或其父類對象措近。

package day04
class LowerBoundDemo[T] {
  // 將lowerbound約束到方法上
  def say[R>:T](r:R) = println(s"say ${r}")
}
object LowerBoundDemo{
  def main(args: Hainiurray[String]): Unit = {
    // new對象時指定泛型是Hainiu類型
    val demo = new LowerBoundDemo[Hainiu]
    // say方法是lowerbound約束溶弟， 只有Hainiu或Hainiu的父類可以通過約束
    demo.say[Hainiu](new Hainiu)
    demo.say[HainiuSupper](new HainiuSupper)
    // Hainiu的子類是不能通過約束的
//    demo.say[HainiuSub](new HainiuSub)
    // 如果調(diào)用方法時不加泛型，那就約束通過（不約束）
    demo.say(new HainiuSub)
  }
}
class HainiuSupper
class Hainiu extends HainiuSupper
class HainiuSub extends Hainiu

22.2.3 ViewBound [B <% A]

ViewBound 用在泛型類或泛型方法上熄诡，通過隱式轉(zhuǎn)換把 B類型轉(zhuǎn)換成A類型可很。

示例：

已知類 HainiuWork，對HainiuWork的兩個對象作比較凰浮。

class HainiuWork(val company: String, val money: Int, val holiday: Int) {
  override def toString: String = {
    s"company:${company}, money:${money}, holiday:${holiday}"
  }
}

java的實現(xiàn)方法：定義外部比較器我抠，用外部比較器去實現(xiàn)。

scala 用 viewbound 實現(xiàn)方法：通過隱式轉(zhuǎn)換將 HainiuWork 轉(zhuǎn)成 Ordered[HainiuWork]袜茧，然后通過Ordered 實現(xiàn)比較菜拓。

Ordered 是什么？

Ordered特質(zhì)更像是rich版的Comparable接口笛厦，除了compare方法外纳鼎，更豐富了比較操作（<, >, <=, >=）。

trait Ordered[A] extends Any with java.lang.Comparable[A] {
    def compare(that: A): Int    // 內(nèi)部比較器的比較方法
    def <  (that: A): Boolean = (this compare that) <  0
    def >  (that: A): Boolean = (this compare that) >  0
    def <= (that: A): Boolean = (this compare that) <= 0
    def >= (that: A): Boolean = (this compare that) >= 0
    def compareTo(that: A): Int = compare(that)   // 外部比較器的比較方法

比較代碼實現(xiàn)：

// Ordered 支持 > 操作
class ViewBoundDemo[W <% Ordered[W]] {
  def choose(work1: W, work2: W): W = {
    if (work1 > work2) work1 else work2
  }
}
object ViewBoundDemo {
  def main(args: Array[String]): Unit = {
    import MyPredef.selectWork
    val demo = new ViewBoundDemo[HainiuWork]
    
    val work1 = new HainiuWork("金融", 20000, 16)
    val work2 = new HainiuWork("互聯(lián)網(wǎng)", 20000, -6)
        
    // 通過隱式轉(zhuǎn)換將 HainiuWork --> Ordered[HainiuWork]
    println(demo.choose(work1, work2))
  }
}
class HainiuWork(val company: String, val money: Int, val holiday: Int) {
  override def toString: String = {
    s"go to ${company},happy holiday ${holiday}"
  }
}

隱式轉(zhuǎn)換函數(shù)實現(xiàn)

  implicit val selectWork = (s:HainiuWork) => new Ordered[HainiuWork]{
    override def compare(that: HainiuWork) = {
      // 先比較工資，工資相同比較假期
      if(s.money == that.money){
        s.holiday - that.holiday
      }else{
        s.money - that.money
      }
    }
  }

22.2.4 ContextBound [B : A]

ContextBound 用在泛型類或泛型方法上贱鄙，通過隱式轉(zhuǎn)換給B類型增加個隱式值A[B]類型劝贸。

還是對HainiuWork的兩個對象作比較。

scala 用 ContextBound 實現(xiàn)方法：通過隱式轉(zhuǎn)換將 HainiuWork 轉(zhuǎn)成 Ordering[HainiuWork] 逗宁。

file

實現(xiàn)邏輯：

package day04
class ContextBoundDemo[T] {
  // 帶有隱式參數(shù)的方法映九，那調(diào)用時，當前環(huán)境得有Ordering[T] 類型的隱式對象
  def chooseBigger(w1:T, w2:T)(implicit ord:Ordering[T]):T = {
    if(ord.gt(w1, w2)) w1 else w2
  }
}
object ContextBoundDemo{
  def main(args: Array[String]): Unit = {
    val w1 = new HainiuWork("互聯(lián)網(wǎng)1", 30000, -3)
    val w2 = new HainiuWork("互聯(lián)網(wǎng)2", 20000, 20)
    val demo = new ContextBoundDemo[HainiuWork]
    // 在調(diào)用前瞎颗，引入隱式對象
    import util.MyPredef.HWOrdering
    val bigger = demo.chooseBigger(w1, w2)
    println(s"更幸福的是：${bigger}")
  }
}

升級版：

package day04
// 當new對象時件甥，通過隱式轉(zhuǎn)換會生成隱式的Ordering[T]
class ContextBoundDemo2[T : Ordering] {
  // 帶有隱式參數(shù)的方法，那調(diào)用時哼拔，當前環(huán)境得有Ordering[T] 類型的隱式對象
  def chooseBigger(w1:T, w2:T):T = {
    // 方法1：
//    val ord = implicitly[Ordering[T]]
    // 方法2：
//    val ord = Ordering[T]
//    if(ord.gt(w1, w2)) w1 else w2
    // 方法3：
    import Ordered.orderingToOrdered
    if(w1 > w2) w1 else w2
  }
}
object ContextBoundDemo2{
  def main(args: Array[String]): Unit = {
    val w1 = new HainiuWork("互聯(lián)網(wǎng)1", 30000, -3)
    val w2 = new HainiuWork("互聯(lián)網(wǎng)2", 20000, 20)
    import util.MyPredef.HWOrdering
    val demo = new ContextBoundDemo2[HainiuWork]
    val bigger = demo.chooseBigger(w1, w2)
    println(s"更幸福的是：${bigger}")
  }
}

22.2.5 協(xié)變與逆變

在聲明Scala的泛型類型時引有，“+”表示協(xié)變（covariance），而“-”表示逆變（contravariance）倦逐。

C[+T]：如果A是B的子類譬正，那么C[A]是C[B]的子類；通常作為返回值類型僻孝。

C[-T]：如果A是B的子類导帝，那么C[B]是C[A]的子類守谓；通常作為參數(shù)類型穿铆。

C[T]：無論A和B是什么關系，C[A]和C[B]沒有從屬關系斋荞。