由于在scala中非常强调泛型或者说类型系统 ，Java和scala是基于jvm的，java1.5以前具体对象的类型与class一一对应，后来引入泛型，如字符串数组或整数数组，都是数组 ，但其实类型是不一样的，在虚拟机内部，并不关心泛型或类型系统。对泛型支持是基于运行时角度考虑的，在虚拟机中泛型被编译运行时是被擦除的， 
在运行时泛型是通过反射方式获取。

一、type 与 class 概念的区别

scala 中 type 是一种更具体的类型, 任何数据都有类型 。 
class 其实是 一种数据结构和基于该数据结构的一种抽象。

在没有泛型之前，类型系统不存在高阶概念，直接与类一一映射，而泛型出现之后，就不在一一映射了

比如定义class List[T] {}, 可以有List[Int] 和 List[String]等具体类型，它们的类是同一个List，但类型则根据不同的构造参数类型而不同。

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

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

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

• 1
• 2
• 3
• 4
• 5

二、typeOf与 classOf 的区别

公共部分

package com.ifly.edu.scala.BestPractice

/**
 *  calss 和type  区别
 * Created by zhiwang on 2015/8/9.
 */
import scala.reflect.runtime.universe._

class Spark

trait Hadoop

object Flink

class Java {

  class Scala

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19

• class 形式

    println(typeOf[Spark])
    println(classOf[Spark])

• 1
• 2

运行结果

com.ifly.edu.scala.BestPractice.Spark 
class com.ifly.edu.scala.BestPractice.Spark

• trait 形式

    println(typeOf[Hadoop])
    println(classOf[Hadoop])

• 1
• 2

运行结果 
com.ifly.edu.scala.BestPractice.Hadoop 
interface com.ifly.edu.scala.BestPractice.Hadoop

• 对象 形式

//      println(typeOf[Flink])   //静态对象是没有 typeof
//      println(classOf[Flink])  //静态对象是没有 classof

• 1
• 2

运行结果

• 嵌套类 形式

    val java1 = new Java
    val java2 = new Java
    val scala1 = new java1.Scala
    val scala2 = new java2.Scala

    println(typeOf[java1.Scala])
    println(classOf[java1.Scala])

• 1
• 2
• 3
• 4
• 5
• 6
• 7

运行结果 
java1.Scala 
class com.ifly.edu.scala.BestPractice.Java$Scala

三、classOf和getClass区别

classOf获取运行时的类型。classOf[T] 相当于 java中的T.class

scala> class  A
scala> val a = new A
scala> a.getClass
res2: Class[_ <: A] = class A
scala> classOf[A]
res3: Class[A] = class A

• 1
• 2
• 3
• 4
• 5
• 6

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

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

• 1
• 2

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

scala> val c:Class[A] = a.getClass
<console>:9: error: type mismatch;

• 1
• 2