关于 Scala 界定、隐式转换的一些知识（五）——上下文界定

在上一节中，我们提到了 Ordering 和 Ordered 的区别，这里再回顾一下：
Ordering 继承了 Comparator，而 Comparator 的 compare 方法有两个参数：A、B，是对 A、B 进行比较；
Ordered 继承了 Comparable，而 Comparable 的 compareTo 方法的参数 是被比较的对象：B，compareTo 的调用者即自身的类 是要比较的对象：A，是对 A、B 进行比较。
Ordering 和 Ordered 完全继承了 它们父类的比较特性。我们接下来介绍 上下文界定，上一节介绍了 Ordered，在这节也会引出 Ordering。并在最后思考一个问题：为什么 上下文界定 要用 Ordering，它可以用 Ordered 来实现么？我们带着这个问题来学习。

上下文界定（Context Bound）是 Scala 2.8 以后引入的一个新的语法特性，
类型变量界定 <: 描述的是 ”is a” 的关系，视图界定 <% 描述的是 “can be seen as” 的关系，而上下文界定描述的则是某种类型 “has a” 的关系。
上下文界定的语言格式为 T：M，其中 M 是一个泛型，这种形式要求存在一个 M[T] 类型的隐式值（隐式值、隐式参数 我们会在后面的系列文章中介绍）。

下面的代码演示了上下文界定的使用：

//PersonOrdering 混入了 Ordering 特质
class PersonOrdering extends Ordering[Person] {
    override def compare(x: Person, y: Person): Int = {
        x.name - y.name
    }
}

case class Person(val name: String) {
    println("正在构造对象: " + name)
}

//下面的代码定义了一个上下文界定
//它的意思是在对应作用域中，必须存在一个类型为 Ordering[T] 的隐式值，该隐式值可以作用于内部的方法

class Pair[T: Ordering](val first: T, val second: T) {
    //smaller 方法中有一个隐式参数，该隐式参数类型为 Ordering[T]
    def smaller(implicit ord: Ordering[T]) = {
        if(ord.compare(first, second) > 0) first else second
    }
}

object ConextBound extends App {
    //定义一个隐式值，它的类型为 Ordering[Person]
    implicit val p1 = new PersonOrdering

    val p = new Pair(Person("123"), Person("456"))

    //不给函数指定参数，此时会查找一个隐式值，该隐式值类型为 Ordering[Person]
    //根据上下文界定的要求，p1 正好满足要求
    //因此它会作为 smaller 的隐式参数传入，从而调用 ord.compare(first,second) 方法进行比较
    println(p.smaller)
}

代码class Pair[T: Ordering](val first: T, val second: T)中的[T: Ordering]表示其泛型参数为一个上下文界定，
在使用时要求代码中存在一个类型为Ordering[T]的隐式值，该隐式值在调用def smaller(implicit ord:Ordering[T])方法时被传入，
代码中的implicit val p1 = new PersonOrdering便是我们定义的这个类型为Ordering[T]的隐式值。
有时候也希望ord.compare(first, second) > 0的比较形式可以写为 first > second这种直观比较形式，
此时可以省去 smaller 函数的隐式参数，并引入 Ordering 到 Ordered 的隐式转换，代码如下：

class PersonOrdering extends Ordering[Person] {
    override def compare(x: Person, y: Person): Int = {
        if(x.name > y.name) 1 else -1
    }
}

case class Person(valname: String) {
    println("正在构造对象: " + name)
}

class Pair[T:Ordering](val first: T, val second: T) {
    //引入 Ordering 到 Ordered 的隐式转换
    //在查找作用域范围内的 Ordering[T] 的隐式值
    //本例的话是 implicitval p1 = new PersonOrdering
    //编译器看到比较方式是 < 的方式进行的时候，会自动进行
    //隐式转换，转换成 Ordered，然后调用其中的 < 方法进行比较

    import Ordered.orderingToOrdered;

    def smaller = {
        if(first < second) first else second
    }
}

object ConextBound extendsApp {
    implicit val p1 = new PersonOrdering
    val p = new Pair(Person("123"), Person("456"))
    println(p.smaller)
}

接下来我们思考开头提出的问题，可以用 Ordered 替换 Ordering 来举例 上下文界定吗？如果可以，该怎么替换？如果不可以，为什么不可以呢？

如果读者可以仔细看笔者 这几篇文章：

• Java Comparable 和 Comparator
• 关于 Scala 界定、隐式转换的一些知识（四）——Ordering 和 Ordered

应该可以得出答案，笔者在这里给出自己的想法：
本节开头提到，Ordering 的 compare 方法是对它的两个参数进行比较，而 Ordered 是通过一个 比较者 调用 compare 方法，和 compare 方法的参数 进行比较。
在 Pair 类中，smaller 方法中有一个隐式参数，通过这个隐式参数来调用 Ordering 的 compare 方法，对其两个参数进行比较，而 这个隐式参数 是最终查找 implicit val p1 = new PersonOrdering 获得的，PersonOrdering 如果不是继承自 Ordering 而是 Ordered，那么 smaller 方法就不需要隐式参数了，它可以直接通过自身 调用 compare 方法，而不再需要一个 隐式值来构造一个 Comparator 去专门做比较这件事。

上面也提到了，如果希望 ord.compare(first, second) > 0的比较形式 可以写为 上一节中 first > second这种直观比较形式，可以在代码中引入import Ordered.orderingToOrdered;

不知道读者有没有捋清楚，逻辑确实有点绕，如果没搞懂，也没关系，这其实不是重点。
但搞清楚笔者提出的问题，会对 scala 语法的更深入学习有所帮助。