Scala 之类型约束——上下文界定（Context Bounds）

/**
  * 1) 要求：使用上下文界定+隐式参数的方式，比较两个Person对象的年龄大小
  * 2) 要求：使用Ordering实现比较
  */
object ContextBounds {

  //定义一个隐式值
  implicit val personCompartor = new Ordering[Person] {
    override def compare(p1: Person3, p2: Person): Int = {
      p1.age - p2.age
    }
  }

def main(args: Array[String]): Unit = {

    val jack = new Person("jack", 20)
    val tom = new Person("tom", 30)

    val compareComm1 = new CompareComm1(jack, tom)
    println(compareComm1.greater)
    println("---------------------")

    val compareComm2 = new CompareComm2(jack, tom)
    println(compareComm2.geatter)

    println("--------------------------")
    val compareComm3 = new CompareComm3(jack, tom)
    println(compareComm3.greatter)

  }

}


// 一个普通漫的personl类
class Person(val name: String, val age: Int) {

  override def toString: String = this.name + "\t" + this.age
}

/** 方式1
  * implicit comparetor: Ordering[T] 是一个隐式参数
  * 前面Ordered , Ordering
  * Ordered和Ordering的区别
  * Ordering继承了java中的Comparator接口，而Ordered继承了java的Comparable接口。
  * 在java中的Comparator是一个外部比较器（需要定义一个类来实现比较器），而Comparable则是一个内部比较器，在类内部重载compareTo函数。
  *
  */

class CompareComm[T: Ordering](obj1: T, obj2: T)(implicit comparetor: Ordering[T]) {

  def greater = if (comparetor.compare(obj1, obj2) > 0) obj1 else obj2
}


/**
  * 方式二
  * 隐式参数也可以直接写到方法中
  */

class CompareComm2[T: Ordering](obj1: T, obj2: T) {
  def geatter = {
    def f1(implicit comparetor: Ordering[T]) = comparetor.compare(obj1, obj2)

    if (f1 > 0) obj1 else obj2
  }
}

/**
  * 方式3,使用implicitly语法糖，最简单(推荐使用)
  */


class CompareComm3[T: Ordering](obj1: T, obj2: T) {
  def greatter = {
    //发生隐式转换，获取到隐式值 personComparetor
    val comparetor = implicitly[Ordering[T]]

    if (comparetor.compare(obj1, obj2) > 0) obj1 else obj2

  }
}