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)
  }
}