面向 Java 开发人员的 Scala 指南: 包和访问修饰符

在现实生活中，代码一定要引用并打包，在本期（第七期） 面向 Java 开发人员的 Scala 指南 系列中，Ted Neward 介绍了 Scala 的包和访问修饰符功能，纠正了以前的疏忽。然后，他继续探讨了 Scale 中的函数内容：“apply” 机制。

最近，读者的反馈让我意识到在制作本系列的过程中我遗漏了 Scala 的语言的一个重要方面：Scala 的包和访问修饰符功能。所以在研究该语言的函数性元素 apply 机制前，我将先介绍包和访问修饰符。
打包
为了有助于隔离代码，使其不会相互冲突，Java™ 代码提供了 package 关键词，由此创建了一个词法命名空间，用以声明类。本质上，将类 Foo 放置到名为 com.tedneward.util 包中就将正式类名修改成了 com.tedneward.util.Foo；同理，必须按该方法引用类。如果没有，Java 编程人员会很快指出，他们会 import 该包，避免键入正式名的麻烦。的确如此，但这仅意味着根据正式名引用类的工作由编译器和字节码完成。快速浏览一下 javap 的输出，这点就会很明了。

关于本系列 Ted Neward 将和您一起深入探讨 Scala 编程语言。在这个新的 developerWorks 系列 中，您将深入了解 Sacla，并在实践中看到 Scala 的语言功能。进行比较时，Scala 代码和 Java 代码将放在一起展示，但（您将发现）Scala 中的许多内容与您在 Java 编程中发现的任何内容都没有直接关联，而这正是 Scala 的魅力所在！如果用 Java 代码就能够实现的话，又何必再学习 Scala 呢？

然而，Java 语言中的包还有几个特殊的要求：一定要在包所作用的类所在的 .java 文件的顶端声明包（在将注释应用于包时，这一点会引发很严重的语言问题）；该声明的作用域为整个文件。这意味着两个跨包进行紧密耦合的类一定要在跨文件时分离，这会致使两者间的紧密耦合很容易被忽略。
Scala 在打包方面所采取的方法有些不同，它结合使用了 Java 语言的 declaration 方法和 C# 的 scope（限定作用域）方法。了解了这一点，Java 开发人员就可以使用传统的 Java 方法并将 package 声明放在 .scala 文件的顶部，就像普通的 Java 类一样；包声明的作用域为整个文件，就像在 Java 代码中一样。而 Scala 开发人员则可以使用 Scala 的包 “（scoping）限定作用域” 方法，用大括号限制 package 语句的作用域，如清单 1 所示：

清单 1. 简化的打包

package com{  package tedneward  {    package scala    {      package demonstration      {        object App        {          def main(args : Array[String]) : Unit =          {            System.out.println("Howdy, from packaged code!")            args.foreach((i) => System.out.println("Got " + i) )          }        }      }    }  }}

这个代码有效地声明了类 App，或者更确切的说是一个称为 com.tedneward.scala.demonstration.App 的单个类。注意 Scala 还允许用点分隔包名，所以清单 1 中的代码可以更简洁，如清单 2 所示：

清单 2. 简化了的打包（redux）

package com.tedneward.scala.demonstration{  object App  {      def main(args : Array[String]) : Unit =      {        System.out.println("Howdy, from packaged code!")        args.foreach((i) => System.out.println("Got " + i) )      }  }}

用哪一种样式看起来都比较合适，因为它们都编译出一样的代码构造（Scala 将继续编译并和 javac 一样在声明包的子目录中生成 .class 文件）。
导入
与包相对的当然就是 import 了，Scala 使用它将名称放入当前词法名称空间。本系列的读者已经在此前的很多例子中见到过 import 了，但现在我将指出一些让 Java 开发人员大吃一惊的 import 的特性。
首先，import 可以用于客户机 Scala 文件内的任何地方，并非只可以用在文件的顶部，这样就有了作用域的关联性。因此，在清单 3 中，java.math.BigInteger 导入的作用域被完全限定到了在 App 对象内部定义的方法，其他地方都不行。如果 mathfun 内的其他类或对象要想使用 java.math.BigInteger，就需要像 App 一样导入该类。如果 mathfun 的几个类都想使用 java.math.BigInteger，可以在 App 的定义以外的包级别导入该类，这样在包作用域内的所有类就都导入 BigInteger 了。

清单 3. 导入的作用域

package com{  package tedneward  {    package scala    {        // ...            package mathfun      {        object App        {          import java.math.BigInteger                  def factorial(arg : BigInteger) : BigInteger =          {            if (arg == BigInteger.ZERO) BigInteger.ONE            else arg multiply (factorial (arg subtract BigInteger.ONE))          }                  def main(args : Array[String]) : Unit =          {            if (args.length > 0)              System.out.println("factorial " + args(0) +                " = " + factorial(new BigInteger(args(0))))            else              System.out.println("factorial 0 = 1")          }        }      }    }  }}

不只如此，Scala 还不区分高层成员和嵌套成员，所以您不仅可以使用 import 将嵌套类型的成员置于词法作用域中，其他任何成员均可；例如，您可以通过导入 java.math.BigInteger 内的所有名称，使对 ZERO 和 ONE 的限定了作用域的引用缩小为清单 4 中的名称引用：

清单 4. 静态导入

package com{  package tedneward  {    package scala    {        // ...              package mathfun      {        object App        {          import java.math.BigInteger          import BigInteger._                  def factorial(arg : BigInteger) : BigInteger =          {            if (arg == ZERO) ONE            else arg multiply (factorial (arg subtract ONE))          }                  def main(args : Array[String]) : Unit =          {            if (args.length > 0)              System.out.println("factorial " + args(0) +                " = " + factorial(new BigInteger(args(0))))            else              System.out.println("factorial 0 = 1")          }        }      }    }  }}

您可以使用下划线（还记得 Scala 中的通配符吧？）有效地告知 Scala 编译器 BigInteger 内的所有成员都需要置入作用域。由于 BigInteger 已经被先前的导入语句导入到作用域中，因此无需显式地使用包名限定类名。实际上，可以将所有这些都结合到一个语句中，因为 import 可以同时导入多个目标，目标间用逗号隔开（如清单 5 所示）：

清单 5. 批量导入

package com{  package tedneward  {    package scala    {        // ...              package mathfun      {        object App        {          import java.math.BigInteger, BigInteger._                  def factorial(arg : BigInteger) : BigInteger =          {            if (arg == ZERO) ONE            else arg multiply (factorial (arg subtract ONE))          }                  def main(args : Array[String]) : Unit =          {            if (args.length > 0)              System.out.println("factorial " + args(0) +                " = " + factorial(new BigInteger(args(0))))            else              System.out.println("factorial 0 = 1")          }        }      }    }  }}

这样您可以节省一两行代码。注意这两个导入过程不能结合：先导入 BigInteger 类本身，再导入该类中的各种成员。
也可以使用 import 来引入其他非常量的成员。例如，考虑一下清单 6 中的数学工具库（或许不一定有什么价值）：

清单 6. Enron 的记帐代码

package com{  package tedneward  {    package scala    {        // ...            package mathfun      {        object BizarroMath        {          def bizplus(a : Int, b : Int) = { a - b }          def bizminus(a : Int, b : Int) = { a + b }          def bizmultiply(a : Int, b : Int) = { a / b }          def bizdivide(a : Int, b : Int) = { a * b }        }      }    }  }}