Scala 包和引入

摘自《快学Scala》

0.重点

• 包可以像内部类那样嵌套
• 包路径不是绝对路径
• 包声明链x.y.z并不自动将中间包x和x.y变成可见
• 位于文件顶部不带花括号的包声明在整个文件范围内有效
• 包对象可以持有函数和变量
• 引入语句可以引入包，类和对象
• 引入语句可以出现在任何位置
• 引入语句可以重命名和隐藏特定成员
• java.lang, scala和Predef 总是被引入

包

Scala的包和Java的包或者C++的命名空间的目的是相同的：管理大型程序中的名称。
如：
Map这个名称可以同时出现在scala.collection.immutable和scala.collection.mutable包而不会冲突。要访问它们中的任何一个，可以使用完全限定的名称scala.collection.immutable.Map或scala.collection.mutable.Map,也可以使用引入语句提供一个更短小的别名。
要增加条目到包中，可以将其包含在包语句当中，如：

package com{
    package horstmann{
        package impatient{
            class Employee
            ...
        }
    }
}

这样，类名Employee就可以在任意位置以com.horstmann.impatient.Employee访问到了。
与对象或类的定义不同，同一个包可以定义在多个文件当中。上面这段代码可能出现在Employ.scala中，另一个名为Manager.scala的文件可能会包含:

package com{
    package horstmann{
        package impatient{
            class Manager
            ...
        }
    }
}

**不需要将Employee.scala和Manager.scala放在com/hortmann/impatient目录中。

2.作用域规则

在Scala中，包的作用域比起Java更加前后一致。Scala的包和其他作用域一样支持嵌套，你可以访问上层作用域中的名称。如：

package com{
    package horstmann{
        package Utils{
            def percentOf(value:Double,rate:Double)=value * rate /100
            ...
        }
        package impatient{
            class Employee{
                def giveRaise(rate:scala.Double){
                    salary += Utils.percentOf(salary, rate)
                }
            }
        }
    }
}

绝对包名：

val subordinates = _root_.scala.collection.mutable.ArrayBuffer[Employee]

3.串联式包语句

package com.horstmann.impatient{
    //com和com.horstmann的成员在这里不可见
    package people{
        clas Person
        ...
    }
}

这样的包语句限制了可见的成员，现在com.horstmann.collection包不再能够以collection访问到了。

4.文件顶部标记法

除了用嵌套标记法以外，也可以在文件顶部使用package语句，不带花括号。例如：

package com.horstmann.impatient
package people

class Person
...

这等同于

package com.horstmann.impatient{
    package people{

        class Person
        ...
        //直到文件末尾
    }
}

如果文件中的所有代码属于同一个包的话（这也是通常的情形），这是更好的做法。
在上面的示例中，文件的所有内容都属于com.horstmann.impatient.people，但com.horstmann.impatient包的内容是可见的，可以被直接饮用。

5.包对象

包可以包含类，对象和特质，但不能包含函数或变量的定义。
每个包都可以有一个包对象，你需要在父包中定义它，且名称与子包一样，例如：

package com.hordstmann.impatient
package object people{
    val defaultName = "John Q.Public"

}
package people{
    class Person{
        var name = defaultName //从包对象拿到的常量
    }
    ...
}

//defaultName不需要加限定词，因为它位于同一个包内，在其他地方，这个常量可以用com.horstmann.impatient,.people.defaultName访问。

6.包可见性

以下方法在它自己的包中可见：

package com.horstmann.impatient.people
class Person{
    private[people] def description = "A person with name " + name
    ...
}
//可以将可见度延展到上层包
private[impatient] def description = "A person with name " + name

7.引入

引入语句让你可以使用更短的名称而不是原来较长的名称：

import java.awt.Color

这样，就可以在代码中写Color而不是java.awt.Color了。

//引入某个包的全部成员：
import java.awt._

//引入类或对象的所有成员：
import java.awt.Color._
val c1 =RED //Color.RED
val c2 =- decode("#ff0000")  //Color.decode

8.任何地方都可以声明引入

在Scala中，import语句可以出现在任何地方，并不仅限于文件顶部。import的效果一直延伸到包含该语句的块末尾。

class Manager{
    import scala.collection.mutable._
    val subordinates = new ArrayBuffer[Employee]
}

通过将引用放置在需要这些引入的地方，可以大幅减少可能的名称冲突。

9.重命名和隐藏方法

//选取器 {}
import java.awt.{Color, Font}
//选取器语法还允许重命名选到的成员
import java.util.{HashMap => JavaHashMap}
import scala.collection.mutable._

//这样，JavaHashMap就是java.util.HashMap,而HashMap则对应scala.collection.mutable.HashMap

//选取器HashMap=>_将隐藏某个成员名而不是重命名它，这仅在你需要引入其他成员时有用：
import java.util.{HashMap => _,_}
import scala.collection.mutable._
//现在，HashMap无二义的指向scala.collection.mutable.HashMap，因为java.util.HashMap被隐藏起来了。

10.隐式引入

每个Scala程序都隐式的以如下代码开始：

import java.lang._
import scala._
import Predef._