Scala入门到精通——第二十节 类型參数
Posted ljbguanli
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Scala入门到精通——第二十节 类型參数相关的知识,希望对你有一定的参考价值。
本节主要内容
- Ordering与Ordered特质
- 上下文界定(Context Bound)
- 多重界定
- 类型约束
1. Ordering与Ordered特质
在介绍上下文界定之前,我们对scala中的Ordering与Ordered之间的关联与差别进行解说,先看Ordering、Ordered的类继承层次体系:
通过上面两个图能够看到,Ordering混入了java中的Comparator接口。而Ordered混入了java的Comparable接口。我们知道java中的Comparator是一个外部比較器。而Comparable则是一个内部比較器,比如:
//以下是定义的Person类(Java)
public class Person {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
Person(String name){
this.name=name;
}
}
//Comparator接口,注意它是在java.util包中的
public class PersonCompartor implements Comparator<Person>{
@Override
public int compare(Person o1, Person o2) {
if (o1.getName().equalsIgnoreCase(o2.getName())) {
return 1;
}else{
return -1;
}
}
public static void main(String[] args){
PersonCompartor pc=new PersonCompartor();
Person p1=new Person("摇摆少年梦");
Person p2=new Person("摇摆少年梦2");
//以下是它的对象比較使用方式
//能够看它。这是通过外部对象进行方法调用的
if(pc.compare(p1, p2)>0) {
System.out.println(p1);
}else{
System.out.println(p2);
}
}
}
而Comparable接口是用于内部比較,Person类自己实现Comparable接口。代码例如以下
public class Person implements Comparable<Person>{
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
Person(String name){
this.name=name;
}
@Override
public int compareTo(Person o) {
if (this.getName().equalsIgnoreCase(o.getName())) {
return 1;
}else{
return -1;
}
}
}
public class PersonComparable {
public static void main(String[] args) {
Person p1=new Person("摇摆少年梦");
Person p2=new Person("摇摆少年梦2");
//对象自身与其他对象比較,而不须要借助第三方
if(p1.compareTo(p2)>0) {
System.out.println(p1);
}else{
System.out.println(p2);
}
}
}
从上述代码中能够看到Comparable与Comparator接口两者的本质不同。因此Ordering混入了Comparator,Ordered混入了Comparator,它们之间的差别和Comparable与Comparator间的差别是同样的。
这里先给出一个Ordered在scala中的使用方法,Ordering的使用方法,将在上下文界定的时候详细解说
case class Student(val name:String) extends Ordered[Student]{
override def compare(that:Student):Int={
if(this.name==that.name)
1
else
-1
}
}
//将类型參数定义为T<:Ordered[T]
class Pair1[T<:Ordered[T]](val first:T,val second:T){
//比較的时候直接使用<符号进行对象间的比較
def smaller()={
if(first < second)
first
else
second
}
}
object OrderedViewBound extends App{
val p=new Pair1(Student("摇摆少年梦"),Student("摇摆少年梦2"))
println(p.smaller)
}
2. 上下文界定
在第十七节中的类型參数(一)中,我们提到视图界定能够跨越类继承层次结构,其后面的原理是隐式转换。本节要介绍的上下文界定採用隐式值来实现。上下文界定的类型參数形式为T:M的形式。当中M是一个泛型,这样的形式要求存在一个M[T]类型的隐式值:
//PersonOrdering混入了Ordering,它与实现了Comparator接口的类的功能一致
class PersonOrdering extends Ordering[Person]{
override def compare(x:Person, y:Person):Int={
if(x.name>y.name)
1
else
-1
}
}
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],依据上下文界定的要求。该类型正好满足要求
//因此它会作为smaller的隐式參数传入,从而调用ord.compare(first, second)方法进行比較
println(p.smaller)
}
有时候也希望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(val name:String){
println("正在构造对象:"+name)
}
class Pair[T:Ordering](val first:T,val second:T){
//引入odering到Ordered的隐式转换
//在查找作用域范围内的Ordering[T]的隐式值
//本例的话是implicit val p1=new PersonOrdering
//编译器看到比較方式是<的方式进行的时候。会自己主动进行
//隐式转换,转换成Ordered。然后调用当中的<方法进行比較
import Ordered.orderingToOrdered;
def smaller={
if(first<second)
first
else
second
}
}
object ConextBound extends App{
implicit val p1=new PersonOrdering
val p=new Pair(Person("123"),Person("456"))
println(p.smaller)
}
3. 多重界定
多重界定具有多种形式,比如:
T:M:K //这意味着在作用域中必须存在M[T]、K[T]类型的隐式值
T<%M<%K //这意味着在作用域中必须存在T到M、T到K的隐式转换
K>:T<:M //这意味着M是T类型的超类,K也是T类型的超类
…..
class A[T]
class B[T]
object MutilBound extends App{
implicit val a=new A[String]
implicit val b=new B[String]
//多重上下文界定。必须存在两个隐式值,类型为A[T],B[T]类型
//前面定义的两个隐式值a,b便是
def test[T:A:B](x:T)=println(x)
test("摇摆少年梦")
implicit def t2A[T](x:T)=new A[T]
implicit def t2B[T](x:T)=new B[T]
//多重视图界定。必须存在T到A。T到B的隐式转换
//前面我们定义的两个隐式转换函数就是
def test2[T <% A[T] <% B[T]](x:T)=println(x)
test2("摇摆少年梦2")
}
4. 类型约束
本节部分实验来自:http://hongjiang.info/scala-type-contraints-and-specialized-methods/,感谢原作者的无私奉献
前面讲的类型变量界定、视图界定都是将泛型限定在一定范围内,而上下文界定则是将类型限定为某一类型。类型约束与下下文界定类型,仅仅只是它是用于推断类型測试,类型约束有以下两种:
T=:=U //用于推断T是否等于U
T<:<U //用于推断T是否为U的子类
像上面的=:=符号非常像一个操作符,但事实上它是scala语言中的类,它们被定义在Predef当中
@implicitNotFound(msg = "Cannot prove that ${From} <:< ${To}.")
sealed abstract class <:<[-From, +To] extends (From => To) with Serializable
private[this] final val singleton_<:< = new <:<[Any,Any] { def apply(x: Any): Any = x }
// not in the <:< companion object because it is also
// intended to subsume identity (which is no longer implicit)
implicit def conforms[A]: A <:< A = singleton_<:<.asInstanceOf[A <:< A]
@implicitNotFound(msg = "Cannot prove that ${From} =:= ${To}.")
sealed abstract class =:=[From, To] extends (From => To) with Serializable
private[this] final val singleton_=:= = new =:=[Any,Any] { def apply(x: Any): Any = x }
object =:= {
implicit def tpEquals[A]: A =:= A = singleton_=:=.asInstanceOf[A =:= A]
}
使用方法简单介绍:
object TypeConstraint extends App{
def test[T](name:T)(implicit ev: T <:< java.io.Serializable)= { name }
//正确。由于String类型属于Serializable的子类
println(test("摇摆少年梦"))
//错误。由于Int类型不属于Seriablizable的子类
println(test(134))
}
那么问题来了,test方法定义了一个隐式參数,它的类型是T <:< java.io.Serializable。即仅仅有T为java.io.Serializable的子类才满足要求,可是我们在程序中并没有指定隐式值。为什么这样也是合法的呢?这是由于Predef中的conforms方法会为我们产生一个隐式值。
那类型约束<:<与类型变量界定<:有什么差别呢?以下给出的代码似乎告诉我们它们之间好像也没有什么差别:
def test1[T<:java.io.Serializable](name:T)= { name }
//编译通过,符合类型变量界定的条件
println(test1("摇摆少年梦"))
//编译通只是,不符号类型变量界定的条件
println(test1(134))
但以下的代码给我们演示的是类型约束<:<与类型变量界定<:之间的差别:
以下的代码演示的是其在一般函数使用时的差别
scala> def foo[A, B <: A](a: A, b: B) = (a,b)
foo: [A, B <: A](a: A, b: B)(A, B)
//类型不匹配时。採用类型推断
scala> foo(1, List(1,2,3))
res0: (Any, List[Int]) = (1,List(1, 2, 3))
//严格匹配。不会採用类型推断
scala> def bar[A,B](a: A, b: B)(implicit ev: B <:< A) = (a,b)
bar: [A, B](a: A, b: B)(implicit ev: <:<[B,A])(A, B)
scala> bar(1,List(1,2,3))
<console>:9: error: Cannot prove that List[Int] <:< Int.
bar(1,List(1,2,3))
^
以下的代码给出的是其在隐式转换时的差别
scala> def foo[B, A<:B] (a:A,b:B) = print("OK")
foo: [B, A <: B](a: A, b: B)Unit
scala> class A; class B;
defined class A
defined class B
scala> implicit def a2b(a:A) = new B
warning: there were 1 feature warning(s); re-run with -feature for details
a2b: (a: A)B
//经过隐式转换后,满足要求
scala> foo(new A, new B)
OK
scala> def bar[A,B](a:A,b:B)(implicit ev: A<:<B) = print("OK")
bar: [A, B](a: A, b: B)(implicit ev: <:<[A,B])Unit
//能够看到,隐式转换在<:<类型约束中无论用
scala> bar(new A, new B)
<console>:12: error: Cannot prove that A <:< B.
bar(new A, new B)
^
加入公众微信号,能够了解很多其他最新Spark、Scala相关技术资讯
以上是关于Scala入门到精通——第二十节 类型參数的主要内容,如果未能解决你的问题,请参考以下文章