Scala学习(七)---包和引入

问题导读：
1.Scala中的包和引入语句是如何工作的？
2.包如何像内部类那样嵌套？
3.引入语句如何重命名和隐藏特定成员？





包和引入

摘要:

在本篇中，你将会了解到Scala中的包和引入语句是如何工作的。相比Java不论是包还是引入都更加符合常规，也更灵活一些。本篇的要点包括：

1. 包也可以像内部类那样嵌套

2. 包路径不是绝对路径

3. 包声明链x.y.z并不自动将中间包x和x.y变成可见

4. 位于文件顶部不带花括号的包声明在整个文件范围内有效

5. 包对象可以持有函数和变量

6. 引入语句可以引入包、类和对象

7. 引入语句可以出现在任何位置

8. 引入语句可以重命名和隐藏特定成员

9. java.lang、scala和Predef总是被引入

1、包

1）、Scala中包含义

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

要增加条目到包中，你可以将其包含在包语句当中，比如：[mw_shl_code=java,true]    package com {

    package horstmann {

    package impatient {

    class Employee

    …….

    }

    }

    }[/mw_shl_code]

这样一来类名Employee就可以在任意位置以com.horstmann.impatient.Employee访问到了

2）、Scala中包定义

与对象或类的定义不同，同一个包可以定义在多个文件当中。前面这段代码可能出现在文件Employee.scala中，而另一个名为Manager.scala的文件可能会包含：[mw_shl_code=scala,true]    package com {

    package horstmann {

    package impatient {

    class Manager

    …….

    }

    }

    }[/mw_shl_code]

这说明了，源文件的目录和包之间并没有强制的关联关系。你不需要将Employee.scala和Manager.scala放在com/horstmann/impatient目录当中

换个角度讲，你也可以在同一个文件当中为多个包贡献内容。Employee.scala文件可以包含：[mw_shl_code=scala,true]    package com {

    package horstmann {

    package impatient {

    class Employee

    …….

    }

    }

    }

    package org {

    package bigjava {

    class Counter

    …….

    }

    }[/mw_shl_code]

2、作用域规则

1）、包嵌套

在Scala中，包的作用域比起java来更加前后一致。Scala的包和其他作用域一样地支持嵌套，你可以访问上层作用域中的名称。例如：[mw_shl_code=scala,true]    package com {

    package horstmann {

    object Utils {

    def percent of (value: Double, rate: Double) = value*rate／100

    ……….

    }

    package impatient {

    class Employee

    …….

    def giveRaise( rate : Scala.Double) {

    salary += Utils.percentOf( salary,rate )

    }

    }

    }

    }[/mw_shl_code]

注意Utils.percentOf修饰符。Utils类定义于父包，所有父包中的内容都在作用域内，因此没必要使用com.horstmann.Utils.precentOf。

2）、包冲突

不过，这里有一个瑕疵。假定有如下代码：[mw_shl_code=scala,true]    package com {

    package horstmann {

    package impatient {

    class Manager {

    val suboardinates = new collection.mutable.ArrayBuffer[Employee]

    …….

    }

    }

    }

    }[/mw_shl_code]

这里我们利用到一个特性，那就是scala包总是被引入。因此，collection包实际上指向的是scala.collection。现在假定有人加入了如下的包，可能位于另一个文件当中：[mw_shl_code=scala,true]    package com {

    package horstmann {

    package collection {

    …….

    }

    }

    }[/mw_shl_code]

这下Manager类将不再能通过编译。编译器尝试在com.horstmann.collection包中查找mutable成员未果。Manager类的本意是要使用顶级的scala包中的collection包，而不是随便什么存在于可访问作用域中的子包

3）、包冲突方案

在Java中，这个问题不会发生，因为包名总是绝对的，从包层级的最顶端开始。但是在Scala中，包名是相对的，就像内部类的名称一样。内部类通常不会遇到这个问题，因为所有代码都在同一个文件当中，由负责该文件的人直接控制。但是包不一样，任何人都可以在任何时候向任何包添加内容。

解决方法之一是使用绝对包名，以_root_开始，例如：

val subordinates=new _root_.scala.collction.mutable.ArrayButfer[Employee]

另一种做法是使用"串联式"包语句，在后面会详细讲到

3、串联式包语句
包语句可以包含一个"串"，或者说路径区段，例如：[mw_shl_code=scala,true]    package com.horstmann.impatient { // com和com.horstmann的成员在这里不可见

    package people {

    class Person

    }

    }[/mw_shl_code]

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

4、文件顶部标记法

除了我们到目前为止看到的嵌套标记法外，你也可以在文件顶部使用package语句，不带花括号。例如：[mw_shl_code=scala,true]    package com.horstmann.impatient

    package people

    class Person[/mw_shl_code]

这等同于[mw_shl_code=scala,true]    package com.horstmann.impatient {

    package people {

    class Person

    ……

    // 直到文件末尾

    }

    }[/mw_shl_code]

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

5、包对象

包可以包含类、对象和特质，但不能包含函数或变量的定义。很不幸，这是Java虚拟机的局限。把工具函数或常量添加到包而不是某个Utils对象，这是更加合理的做法。包对象的出现正是为了解决这个局限。每个包都可以有一个包对象。你需要在父包中定义它，且名称与子包一样。例如[mw_shl_code=scala,true]    package com.horstmann.impatient

    package object people {

    val defaultName="John Q. Public"

    }

    package people {

    class Person {

    var name=defaultName // 从包对象拿到的常置

    }

    …….

    }

    }[/mw_shl_code]

注意defaultName不需要加限定词，因为它位于同一个包内。在其他地方，这个常量可以用com.horstmann.impatient.people.defaultName访问到。在幕后，包对象被编译成带有静态方法和字段的JVM类，名为package.class，位于相应的包下。对应到本例中，就是com.horstmann.impatient.people.package，其中有一个静态字段defaultName。在JVM中，你可以使用package作为类名。对源文件使用相同的命名规则是好习惯，可以把包对象放到文件com/horstmann/impatient/people/package.scala。这样一来，任何人想要对包增加函数或变量的话，都可以以很容易地找到对应的包对象

6、包可见性

在Java中，没有被声明为public、private或protected的类成员在包含该类的包中可见。在Scala中，你可以通过修饰符达到同样的效果。以下方法在它自己的包中可见：[mw_shl_code=scala,true]    package com.horstmann.impatient.people

    class Person {

    private[people] def description="A person with name "+name

    …….

    }[/mw_shl_code]

你可以将可见度延展到上层包：

private[impatient] def description="A person with name "+name

7、引入
引入语句让你可以使用更短的名称而不是原来较长的名称。写法如下：[mw_shl_code=scala,true]import java.awt.Color[/mw_shl_code]

这样一来，你就可以在代码中写Color而不是java.awt.Color了，这就是引入语句的唯一目的。如果你不介意长名称，你完全不需要使用引入。你也可以引入某个包的全部成员：[mw_shl_code=scala,true]import java.awt._[/mw_shl_code]

这和Java中的通配符*一样。在Scala中，*是合法的标识符。你完全可以定义com.horstmann.*.people这样的包，但请别这样做。你还可以引入类或对象的所有成员:[mw_shl_code=scala,true]    import java.awt.Color._

    val c1 =RED // Color.RED

    val c2=decode("#ff0000") // Color.decode[/mw_shl_code]

这就象Java中的import static。Java程序员似乎挺害怕这种写法，但在Scala中这样的弓很常见。一旦你引入了某个包，你就可以用较短的名称访问其子包。例如：[mw_shl_code=scala,true]    import java.awt._

    def handler(evt: event.ActionEvent) { // java.awt.event.ActionEvent

    ……….

    }[/mw_shl_code]

event包是java.awt包的成员，因此引入语句把它也带进了作用域

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

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

[mw_shl_code=scala,true]    class Manager {

    import scala.collection.mutable._

    val subordinates = new ArrayBuffer[Employee]

    }[/mw_shl_code]

这是个很有用的特性，尤其是对于通配引入而言。从多个源引入大量名称总是让人担心。事实上，有些Java程序员特别不喜欢通配引入，以至于从不使用这个特性，而是让IDE帮他们生成一长串引入语句。通过将引入放置在需要这些引入的地方，你可以大幅减少可能的名称冲突。

9、重命名和隐藏方法

1）、重命名

如果你想要引人包中的几个成员，可以像这样使用选取器( selector)：

import java.awt.Color.{ Color,Font }

选取器语法还允许你重命名选到的成员：[mw_shl_code=scala,true]    import java.util.{ HashMap=>JavaHashMap }

    import scala.collection.mutable._[/mw_shl_code]

这样一来，JavaHashMap就是java.utiI.HashMap，而HashMap则对应scala.collection.mutable.HashMap。

2）、隐藏方法

选取器HashMap =>_将隐藏某个成员而不是重命名它。这仅在你需要引入其他成员时有用：[mw_shl_code=scala,true]    import java.util.{HashMap=>_，_ }

    import scala.collection.mutable._[/mw_shl_code]

现在，HashMap无二义地指向scala.collection.mutable.HashMap，因为java.util.HashMap被隐藏起来了

10、隐式引入

每个Scala程序都隐式地以如下代码开始：[mw_shl_code=scala,true]    import java.lang._

    import scala._

    import Predef._[/mw_shl_code]

和Java程序一样，java.lang总是被引入。接下来，scala包也被引入，不过方式有些特殊。不像所有其他引入，这个引入被允许可以覆盖之前的引入。举例来说，scala.StringBuilder覆盖java.lang.StringBuilder而不是与之冲突。最后，Predef对象被引入。它包含了相当多有用的函数，这些同样可以被放置在scala包对象中，不过Predef在Scala还没有加入包对象之前就存在了。

由于scala包默认被引入，对于那些以scala开头的包，你完全不需要写全这个前缀。例如：

[mw_shl_code=scala,true]collection.mutable.HashMap[/mw_shl_code]

上述代码和以下写法一样好：

[mw_shl_code=scala,true]scala.collection.mutable. HashMap[/mw_shl_code]

资料来源：Scala学习(七)---包和引入