Scala的泛型的使用，泛型和隱式轉換的使用（用傳統的Compare用法與Scala隱式轉換做對比）

首先 我們來看下Scala中常用的幾種泛型

[T <: UpperBound]     （在這邊“：”後面指定的Scala接口的結構）
[T >: LowerBound]
[T <% ViewBound]  視圖界定（用的比較多）
[T : ContextBound]  上下文界定（用的比較多）
[+T]
[-T]

 

1.傳統的Java的Compare的用法

class Boy(val name:String,val faceValue:Int) extends Comparable[Boy]{
  override def compareTo(o: Boy): Int = {
    this.faceValue - o.faceValue
  }



package com.ycit.akka.rpc.YS

/**
  * @author jpf
  * @date 2019/6/6 19:24
  */

class MrRight[T] {
  def choose[T <: Comparable[T]](first: T, second: T): T = {
    if (first.compareTo(second) > 0) first else second
  }
}

object MrRight {
  def main(args: Array[String]): Unit = {
    val b1 = new Boy("jiangpengfei", 99)
    val b2 = new Boy("wangshuzhe", 100)
    /*val choose = new MrRight[Boy]
    val rs = choose.choose(b1,b2)*/
    val arr = Array(b1, b2)
    val rs = arr.sortBy(x => x).reverse
    for (r <- rs) {
      println(r.name)
    }

  }
}

這種傳統的用法將泛型對象和類進行綁定如果比較對象改變就必須修改源代碼，不能夠做到代碼之間的完全解耦。

下面是利用Scala的Ordering 和ordered及隱式轉換和柯里化實現

package com.ycit.akka.rpc.YS

/**
  * @author jpf
  * @date 2019/6/6 20:58
  */

class MissRight[T] {
  //相當於視圖界定（傳入一個匿名函數）
  def choose(first: T, second: T)(implicit ord : T => Ordered[T]): T = {
    if(first > second) first else second
  }
  //相當於 上下文界定 傳入一個隱式轉換的值
  def select(first: T, second: T)(implicit ord : Ordering[T]): T ={
    if(ord.gt(first, second)) first else second
  }

  def random(first: T, second: T)(implicit ord : Ordering[T]): T ={
    import Ordered.orderingToOrdered
    if(first > second) first else second
  }

}
object MissRight {
  def main(args: Array[String]) {
    val mr = new MissRight[Girl]
    val g1 = new Girl("hatanao", 98, 28)
    val g2 = new Girl("sora", 95, 33)
    import MyPreDef.girl2Ordering
    //val g = mr.choose(g1, g2)
    val g = mr.select(g1, g2)
    println(g.name)
  }
}

隱式轉換的門面

package com.ycit.akka.rpc.YS

/**
  * @author jpf
  * @date 2019/6/6 20:06
  */
//視圖  <% 必須傳一個隱式轉換函數
/*class MrLeft[T <% Ordered[T]] {
  def choose(first:T,second:T): T ={
    if (first > second ) first else second
  }
}*/
//上下文界定（必須穿進去一個隱式轉換的值）
class MyLeft[T:Ordering]{
  def  choose(first:T,second:T):T={
    val ord = implicitly[Ordering[T]]
    if (ord.gt(first,second)) first else second
  }

}
object MrLeft{
  def main(args: Array[String]): Unit = {
    import MyPreDef.girl2Ordering
     val myleft = new MyLeft[Girl]
     val g1 = new Girl("jiang",100,21)
     val g2 = new Girl("wang",100,81)

     val rs: Girl = myleft.choose(g1,g2)
    println(rs.name)
  }
}

 普通泛型實現

package com.ycit.akka.rpc.YS

/**
  * @author jpf
  * @date 2019/6/6 20:06
  */
//視圖  <% 必須傳一個隱式轉換函數
/*class MrLeft[T <% Ordered[T]] {
  def choose(first:T,second:T): T ={
    if (first > second ) first else second
  }
}*/
//上下文界定（必須穿進去一個隱式轉換的值）
class MyLeft[T:Ordering]{
  def  choose(first:T,second:T):T={
    val ord = implicitly[Ordering[T]]
    if (ord.gt(first,second)) first else second
  }

}
object MrLeft{
  def main(args: Array[String]): Unit = {
    import MyPreDef.girl2Ordering
     val myleft = new MyLeft[Girl]
     val g1 = new Girl("jiang",100,21)
     val g2 = new Girl("wang",100,81)

     val rs: Girl = myleft.choose(g1,g2)
    println(rs.name)
  }
}