Scala 类型系统:类型与类

在Java里,一直到jdk1.5之前,我们说一个对象的类型(type),都与它的class是一一映射的,通过获取它们的class对象,比如 String.class, int.class, obj.getClass() 等,就可以判断它们的类型(type)是不是一致的。

而到了jdk1.5之后,因为引入了泛型的概念,类型系统变得复杂了,并且因为jvm选择了在运行时采用类型擦拭的做法(兼容性考虑),类型已经不能单纯的用class来区分了,比如 List<String>List<Integer> 的class 都是 Class<List>,然而两者类型(type)却是不同的。泛型类型的信息要通过反射的技巧来获取,同时java里增加了Type接口来表达更泛的类型,这样对于 List<String>这样由类型构造器和类型参数组成的类型,可以通过 Type 来描述;它和 List<Integer> 类型的对应的Type对象是完全不同的。

在Scala里,类型系统又比java复杂很多,泛型从一开始就存在,还支持高阶的概念(后续会讲述)。所以它没有直接用Java里的Type接口,而是自己提供了一个scala.reflect.runtime.universe.Type (2.10后)

在scala里获取类型信息是比较便捷的:

scala> import scala.reflect.runtime.universe._
import scala.reflect.runtime.universe._

scala> class A
defined class A

scala> typeOf[A]
res0: reflect.runtime.universe.Type = A

同样scala里获取类(Class)信息也很便捷,类似:

scala> classOf[A]
res1: Class[A] = class A

另外,因为java的Object里提供了getClass方法,对于对象来说,可以直接调用这个方法

scala> val a = new A
a: A = A@649725e3

scala> a.getClass
res2: Class[_ <: A] = class A

scala> trait T
defined trait T

scala> classOf[T]
res3: Class[T] = interface T

scala> typeOf[T]
res4: reflect.runtime.universe.Type = T

注意,typeOf 和 classOf 方法接收的都是类型符号(symbol),并不是对象实例

scala> object O
defined object O

scala> classOf[O] // 这里O是一个单例对象
<console>:14: error: not found: type O

对于实例,要获取他的 Class 信息,只有通过 getClass 方法

scala> O.getClass
res6: Class[_ <: O.type] = class O$

注意到了,上面的 单例对象O 对应的class是 O$而不是 O,你通过 :javap O 也能看到这个单例反编译后是一个名为O$的java class

而这个单例的类型更有趣了:O.type 看上去像是这个单例内部的一个成员,用这个成员的值表示其类型;实际上.type之前的都可以看做是一种类型路径,这种特殊的类型也叫单例类型,它是面向对象实例的,每个实例都可以通过.type方式表达它的单例类型,这个后续我们再说。

再举一个例子:

scala> class A { class B }  // 嵌套类
defined class A

scala> val a1 = new A
a1: A = A@51ce6f85

scala> val a2 = new A
a2: A = A@5e2a3040

scala> val b1 = new a1.B
b1: a1.B = A$B@3727f0ee

scala> val b2 = new a2.B
b2: a2.B = A$B@4339baec

对于内部类B的实例,它们的class都是相同的: A$B

scala> b1.getClass
res7: Class[_ <: a1.B] = class A$B

scala> b2.getClass
res8: Class[_ <: a2.B] = class A$B

而它们的类型却是不同的:

scala> typeOf[a1.B] == typeOf[a2.B]
res9: Boolean = false

这是因为内部类型依赖外部实例(路径依赖类型),外部实例不同,它们也不同。但还可以对这种类型再抽象

scala> typeOf[a1.B] <:< typeOf[A#B]
res10: Boolean = true

scala> typeOf[a2.B] <:< typeOf[A#B]
res11: Boolean = true

这里A#B涉及到类型投影的概念,以后再讲。

简单的说,类(class)与类型(type)是两个不一样的概念(在java里因为早期一直使用class表达type,并且现在也延续这样的习惯);类型(type)比类(class)更”具体”,任何数据都有类型。类是面向对象系统里对同一类数据的抽象,在没有泛型之前,类型系统不存在高阶概念,直接与类一一映射,而泛型出现之后,就不在一一映射了。比如定义class List[T] {}, 可以有List[Int] 和 List[String]等具体类型,它们的类是同一个List,但类型则根据不同的构造参数类型而不同。

类型一致的对象它们的类也是一致的,反过来,类一致的,其类型不一定一致。

scala> classOf[List[Int]] == classOf[List[String]]
res12: Boolean = true

scala> typeOf[List[Int]] == typeOf[List[String]]
res13: Boolean = false

在jvm里,类的实例数据都是引用形式,而类型没有这个约束,基础类型int,byte,char等就是非引用的。(虽然可以通过int.class来获取Class对象,但并不能找到有定义class int的地方,这只是早期java为了统一用class来承载其类型信息的方式)

classOf与getClass方法的差异

scala> class A
defined class A

scala> val a = new A
a: A = A@33833882

scala> a.getClass
res0: Class[_ <: A] = class A

scala> classOf[A]
res1: Class[A] = class A

上面显示了两者的不同,getClass 方法得到的是 Class[A]的某个子类,而 classOf[A] 得到是正确的 Class[A],但是去比较的话,这两个类型是equals为true的

scala> a.getClass  == classOf[A]
res2: Boolean = true

这种细微的差别,体现在类型赋值时,因为java里的 Class[T]是不支持协变的,所以无法把一个 Class[_ < : A] 赋值给一个 Class[A]

scala> val c:Class[A] = a.getClass
<console>:12: error: type mismatch;
found : Class[?0] where type ?0 <: A
required: Class[A]
Note: ?0 <: A, but Java-defined class Class is invariant in type T.
You may wish to investigate a wildcard type such as `_ <: A`. (SLS 3.2.10)

小结,类型是所有编程语言都有的概念,一切数据都有类型。类更多存在于面向对象语言,非面向对象语言也有“结构体”等与之相似的概念;类是对数据的抽象,而类型则是对数据的”分类”,类型比类更“具体”,更“细”一些。

From: scala类型系统:1) 类型与类


- - - - - - - - End Thank For Your Reading - - - - - - - -