scala 类型 的最详细解释

scala 是一个强类型的语言,但是在编程时可以省略对象的类型.

java中对象类型(type)与类(class)信息

jdk1.5 前 类型与类是一一映射,类一致类型就一致.

1.5 后引入了泛型,jvm 选择运行时擦除类型, 类型不可以只通过类信息进行判断. 比如: List<String>,List<Integer> 的class 都是 Class<List>,然而他们的类型是不相同的,泛型是需要通过反射来进行获得, 同时java通过增加 Type 来表达这种类型.

List<String> 的类型由 类构造器 和 类型参数 组成. 和 List<Integer> 完全不相同.

scala中类型

scala 没有用java自己的类型接口,使用 scala.reflect.runtime.universe.Type 接口

1. 类获得类型或类信息

// 获取类型信息
import scala.reflect.runtime.universe._

class A

typeOf[A]
res44: reflect.runtime.universe.Type = A

// 获取类信息
classOf[A]
res52: Class[A] = class A

1. 对象获得类信息

另外java 中对象获取类信息可以通过 getClass方法,scala继承了这个方法.

val a = new A

a.getClass
res53: Class[_ <: A] = class A

scala 类型与类区别

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

scala> val a1 = new A
scala> val a2 = new A

scala> val b1 = new a1.B
scala> val b2 = new a2.B

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

// 嵌套类的类信息是一致的是 A&B
scala> b1.getClass == b2.getClass
res7: Boolean = true

// 类型是不同的
scala> typeOf[a1.B] == typeOf[a2.B]
res10: Boolean = false

typeOf[a1.B]
res9: reflect.runtime.universe.Type = a1.B

类(class)与类型(type)是两个不一样的概念,类型(type)比类(class)更”具体”，任何数据都有类型。类是面向对象系统里对同一类数据的抽象，在没有泛型之前，类型系统不存在高阶概念，直接与类一一映射，而泛型出现之后，就不在一一映射了。比如定义class List[T] {}, 可以有List[Int] 和 List[String]等具体类型，它们的类是同一个List，但类型则根据不同的构造参数类型而不同。

类包括类型,类型一致他们的类信息也是一致的. 类型不一致,但是类可能一致,类型是所有编程语言都有的概念，一切数据都有类型。类更多存在于面向对象语言，非面向对象语言也有“结构体”等与之相似的概念；类是对数据的抽象，而类型则是对数据的”分类”，类型比类更“具体”，更“细”一些。

scala 内部依赖类型

class A{
     | class B;
     | def foo(b:B) = println(b)
     | }
defined class A

scala> val a1 = new A
a1: A = A@34692767

scala> val a2 = new A
a2: A = A@d9c54cd

scala> val b1 = new a1.B
b1: a1.B = A$B@156aba9a

scala> val b2 = new a2.B
b2: a2.B = A$B@3829edd5

在java 中 内部类创建的对象是相同的,但是scala中b1 和 b2 是不同的类型.

a1.foo(b2)
<console>:17: error: type mismatch;
 found   : a2.B
 required: a1.B
       a1.foo(b2)
              ^

a1.foo方法接受的参数类型为：a1.B，而传入的b2 类型是 a2.B，两者不匹配。

路径依赖类型；比如上面的 A.this.B 就是一个路径依赖类型，B 前面的路径 A.this 随着不同的实例而不同，比如 a1 和 a2 就是两个不同的路径，所以a1.B 与 a2.B也是不同的类型。

1. 内部类定义在Object中: 路径 package.object.Inner
2. 内部类定义在class/trait 里:

class A {
    class B
    val b = new B // 相当于 A.this.B
}   

类路径 A.B

class A  { class B }
class C extends A { val x = new super.B } // 相当于 C.super.B

类路径 C.super.B

怎么让 a1.foo 方法可以接收 b2 参数 ？

类型投影(type projection)

在scala里，内部类型(排除定义在object内部的)，想要表达所有的外部类A实例路径下的B类型，即对 a1.B 和 a2.B及所有的 an.B类型找一个共同的父类型，这就是类型投影，用 A#B的形式表示。

def foo(b: A#B)

结构类型

结构类型(structural type)为静态语言增加了部分动态特性，使得参数类型不再拘泥于某个已命名的类型，只要参数中包含结构中声明的方法或值即可。

def free( res: {def close():Unit} )
{ 
        res.close 
}

free(new { def close()=println("closed") })
closed

也可以使用Type定义别名

type X = { def close():Unit }
defined type alias X
def free(res:X) = res.close
free(new { def close()=println("closed") })
closed

如果某一类实现了close方法也可以直接传入

object A { def close() {println("A closed")} }

free(A)
A closed

结构类型还可以用在稍微复杂一点的“复合类型”中，比如：

scala> trait X1; trait X2;

scala> def test(x: X1 with X2 { def close():Unit } ) = x.close

上面声明test方法参数的类型为：

X1 with X2 { def close():Unit }

表示参数需要符合特质X1和X2同时也要有定义close方法

复合类型

class A extends B with C with D with E

应该理解为 class A extends (B with C with D with E) 这叫做复合类型

也可以通过Type声明别名

scala> type X = X1 with X2
defined type alias X

scala> def test(x:X) = println("OK")
test: (x: X)Unit

scala> class A extends X1 with X2

scala> val a = new A

scala> test(a)
OK

Type 定义类型

type S = String

可以给 String类型起一个别名 S

可以用于抽象类型

scala> trait A { type T ; def foo(i:T) = print(i) }

scala> class B extends A { type T = Int }

scala> val b = new B

scala> b.foo(200)
200

scala> class C extends A { type T = String }

scala> val c = new C

scala> c.foo("hello")
hello

交集类型和联合类型

X with Y with Z 开发交集类型

X or Y or Z 是并集类型,但是scala目前并不支持,可以使用隐式转换来实现

class StringOrInt[T]
object StringOrInt {
  implicit object IntWitness extends StringOrInt[Int]
  implicit object StringWitness extends StringOrInt[String]
}

object Bar {
  def foo[T: StringOrInt](x: T) = x match {
    case _: String => println("str")
    case _: Int => println("int")
  }
}

泛型子类型 父类型

在Java泛型里表示某个类型是Test类型的父类型，使用super关键字：

<T super Test>

//或用通配符的形式：
<? super Test>

scala 中使用

[T >: Test]

//或用通配符:
[_ >: Test]

lower bound适用于把泛型对象当作数据的消费者的场景下:

def append[T >: String] (buf : ListBuffer[T])  = {  
                buf.append( "hi")
}

数组类型

协变 : A 是 B 的子类型, List[A] 也是 List[B] 的子类型

逆变 : A 是 B 的子类型, List[B] 是 List[A] 的子类型

在java中引用类型的数组类型是支持协变的, 即 String[] 类型是 Object[] 的子类型,

比如排序算法:

void sort(Object[] a, Comparator cmp) { … }

数组的协变被用来确保任意参数类型的数组都可以传入排序方法。随着java引入了泛型，sort方法可以用类型参数，因此数组的协变不再有用。只是考虑到兼容性。

scala里不支持数组的协变，以尝试保持比java更高的纯粹性。即 Array[String]的实例对象不能赋给Array[Any]类型的变量。

不同于java里其他泛型集合的实现，数组类型中的类型参数在运行时是必须的，即 [Ljava/lang/String 与 [Ljava/lang/Object 是两个不同的类型，不像 Collection<String> 与 Collection<StringBuilder> 运行时参数类型都被擦拭掉，成为Collection<Object>。

class List[T]  第一个是类型构造器,第二个是类型参数

java 不支持类型参数任然是 泛型, 但是scala支持类型参数是泛型

值类型

默认值类型 Int,Unit,Double ,创建好数组后,初始化 0 ,(), 0.0 进行初始化

然而自定义的值类型进行初始化,在创建一个数组后是用 null 进行填充的.

Null与Nothing

scala 类型系统以Any为根,分为AnyRel和AnyVal 两个分支体系,在AnyRef 底层有一个Null的子类型,它被当做AnyRef的子类型,在两个分支的最底层类型是Nothing,它被当做是AnyRef和AnyVal类型的类型.

Null类型只有一个唯一的值：null，可以被赋给所有的AnyRef类型变量

但null不可以赋值给AnyVal类型：

val i: Int = null

// java里，编译通过，运行失败，空指针异常
int i = (int)((Integer)null);

// scala里，把值为null的Integer拆箱为值类型Int是ok的，得到Int的默认值0
val i = null.asInstanceOf[java.lang.Integer].asInstanceOf[Int]

scala 和 java 的装箱拆箱的不同

在java里基本类型(primitive type) 与引用类型是有明确差异的，虽然提供了自动装箱拆箱的便捷，但在类型上两者是不统一的；而scala里修正这一点，Int类型不再区分int/Integer，类型一致，所以值为null的Integer在通过asInstanceOf[Int]时被当作一个未初始化的Int对待，返回了一个默认值Int(注:asInstanceOf不改变原值，返回一个新值)