Scala学习笔记(九) - 包和引用

Scala中的包和引用感觉上是集合了C#,Java和VB三种的基础上又进行了强化，所以看上去相当的强大与灵活，当然灵活的代价就是掌握起来会有一些复杂。

首先是Scala中的包可以像Java一样使用，例如：

package com.my.io

class XXX

因为Scala并不要求一个文件对应一个类，所以这种写法会把这个文件中的所有类都划给这个包。

同样，因为Scala不要求文件夹的嵌套，所以，你可以像C#那样随便把文件丢哪，然后增加package语句。

当然，你可以像C#的namespace一样使用package语句，例如：

package com.mu.io{

class XXX

}

package是也可以嵌套的，例如：

package com.my.io{

class XXX

package test{

class T

}

}

则类型T的完整路径为： com.mu.io.test.T
很多时候，大家如果定义了嵌套的包，但是包名有冲突的时候，可以使用 _root_来写完成的路径，_root_ 类似于C#中的 global:: 的意思

=====引用==========

Scala中依然使用import作为引用包的关键字，例如：

import com.my.io.XXX // 可以不写XXX的全路径

import com.my.io._ // 引用import com.my.io下的所有类型

import com.my.io.XXX._ //引用import com.my.io.XXX的所有成员

而且Scala中的import可以写在任意地方，这样可以通过外层的作用范围减少引用的范围，例如：

def method(fruit : Fruit){

import fruit ._

println(name)

}

本来name是Fruit的一个成员，现在通过在函数中使用 import fruit ._ 来简化name的编码，这点与VB很像

同时，import语句可以给类型重命名，例如：

import com.my.io.{XXX => HHH}

这样直接使用HHH来代替XXX

也可以一次引用多个，例如：

import com.my.io.{XXX , YYY}

更神奇的是，你可以引用一整个包，同时将一些不需要的名称剔除，例如：

import com.my.io.{XXX => _, _} 这句话是引用com.my.io包下除了XXX以外的所有的类型

==访问修饰符=============

Scala中的访问修饰符只有private，与protected两个，这两个含义与Java/C#中一致，但是这两个可以进行各种组合，例如：

package bobsrockets {
package navigation {
private[bobsrockets] class Navigator {
protected[navigation] def useStarChart() {}
class LegOfJourney {
private[Navigator] val distance = 100
}
private[this] var speed = 200
}
}
package launch {
import navigation._
object Vehicle {
private[launch] val guide = new Navigator
}
}
}

很强大吧。。。╮(╯▽╰)╭

现在如果将这些组合应用到 LegOfJourney.distance上，会有什么样的效果，

private[bobsrockets]：可以在外部包中访问(命名空间内可见)

protected[navigation]：与Java的包可见度相同(包内可见)

private[Navigator] ： 与Java的private相同(类内可见)

private[LegOfJourney]：与Scala中的private相同(本类中可见，父类中不可见)

private[this] ：只有同一个对象中可见

即便在 Navigator类中使用以下代码也会出错

val other = new Navigator

other.speed // 编译错误

只能是 this.speed 使用。

嘛，个人感觉应该用不到这么复杂的访问修饰符吧。。。大概。。。

======================================

Scala中面向对象的以及传统的介绍就到这里了，后面将会介绍Scala中比较特殊的东西，例如函数的柯里化，伴生对象等