从Java走进Scala:包和访问修饰符

开发 后端
在现实生活中,代码一定要引用并打包,在本文中,Ted Neward 介绍了 Scala 的包(package)和访问修饰符功能,纠正了以前的疏忽。然后,他继续探讨了 Scale 中的函数内容:“apply” 机制。

最近,读者的反馈让我意识到在制作本系列的过程中我遗漏了 Scala 的语言的一个重要方面:Scala 的包和访问修饰符功能。所以在研究该语言的函数性元素 apply 机制前,我将先介绍包和访问修饰符。

打包

为了有助于隔离代码,使其不会相互冲突,Java 代码提供了 package 关键词,由此创建了一个词法命名空间,用以声明类。本质上,将类 Foo 放置到名为 com.tedneward.util 包中就将正式类名修改成了 com.tedneward.util.Foo;同理,必须按该方法引用类。如果没有,Java 编程人员会很快指出,他们会 import 该包,避免键入正式名的麻烦。的确如此,但这仅意味着根据正式名引用类的工作由编译器和字节码完成。快速浏览一下 javap 的输出,这点就会很明了。

然而,Java 语言中的包还有几个特殊的要求:一定要在包所作用的类所在的 .java 文件的顶端声明包(在将注释应用于包时,这一点会引发很严重的语言问题);该声明的作用域为整个文件。这意味着两个跨包进行紧密耦合的类一定要在跨文件时分离,这会致使两者间的紧密耦合很容易被忽略。

Scala 在打包方面所采取的方法有些不同,它结合使用了 Java 语言的 declaration 方法和 C# 的 scope(限定作用域)方法。了解了这一点,Java 开发人员就可以使用传统的 Java 方法并将 package 声明放在 .scala 文件的顶部,就像普通的 Java 类一样;包声明的作用域为整个文件,就像在 Java 代码中一样。而 Scala 开发人员则可以使用 Scala 的包 “(scoping)限定作用域” 方法,用大括号限制 package 语句的作用域,如清单 1 所示:

清单 1. 简化的打包

  1. package com  
  2. {  
  3.   package tedneward  
  4.   {  
  5.     package scala  
  6.     {  
  7.       package demonstration  
  8.       {  
  9.         object App  
  10.         {  
  11.           def main(args : Array[String]) : Unit =  
  12.           {  
  13.             System.out.println("Howdy, from packaged code!")  
  14.             args.foreach((i) => System.out.println("Got " + i) )  
  15.           }  
  16.         }  
  17.       }  
  18.     }  
  19.   }  

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

清单 2. 简化了的打包(redux)

  1. package com.tedneward.scala.demonstration  
  2. {  
  3.   object App  
  4.   {  
  5.       def main(args : Array[String]) : Unit =  
  6.       {  
  7.         System.out.println("Howdy, from packaged code!")  
  8.         args.foreach((i) => System.out.println("Got " + i) )  
  9.       }  
  10.   }  

用哪一种样式看起来都比较合适,因为它们都编译出一样的代码构造(Scala 将继续编译并和 javac 一样在声明包的子目录中生成 .class 文件)。

#p#

导入

与包相对的当然就是 import 了,Scala 使用它将名称放入当前词法名称空间。本系列的读者已经在此前的很多例子中见到过 import 了,但现在我将指出一些让 Java 开发人员大吃一惊的 import 的特性。

首先,import 可以用于客户机 Scala 文件内的任何地方,并非只可以用在文件的顶部,这样就有了作用域的关联性。因此,在清单 3 中,java.math.BigInteger 导入的作用域被完全限定到了在 App 对象内部定义的方法,其他地方都不行。如果 mathfun 内的其他类或对象要想使用 java.math.BigInteger,就需要像 App 一样导入该类。如果 mathfun 的几个类都想使用 java.math.BigInteger,可以在 App 的定义以外的包级别导入该类,这样在包作用域内的所有类就都导入 BigInteger 了。

清单 3. 导入的作用域

  1. package com  
  2. {  
  3.   package tedneward  
  4.   {  
  5.     package scala  
  6.     {  
  7.         // ...  
  8.         
  9.       package mathfun  
  10.       {  
  11.         object App  
  12.         {  
  13.           import java.math.BigInteger  
  14.           
  15.           def factorial(arg : BigInteger) : BigInteger =  
  16.           {  
  17.             if (arg == BigInteger.ZERO) BigInteger.ONE  
  18.             else arg multiply (factorial (arg subtract BigInteger.ONE))  
  19.           }  
  20.           
  21.           def main(args : Array[String]) : Unit =  
  22.           {  
  23.             if (args.length > 0)  
  24.               System.out.println("factorial " + args(0) +  
  25.                 " = " + factorial(new BigInteger(args(0))))  
  26.             else 
  27.               System.out.println("factorial 0 = 1")  
  28.           }  
  29.         }  
  30.       }  
  31.     }  
  32.   }  

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

清单 4. 静态导入

  1. package com  
  2. {  
  3.   package tedneward  
  4.   {  
  5.     package scala  
  6.     {  
  7.         // ...  
  8.    
  9.       package mathfun  
  10.       {  
  11.         object App  
  12.         {  
  13.           import java.math.BigInteger  
  14.           import BigInteger._  
  15.           
  16.           def factorial(arg : BigInteger) : BigInteger =  
  17.           {  
  18.             if (arg == ZERO) ONE  
  19.             else arg multiply (factorial (arg subtract ONE))  
  20.           }  
  21.           
  22.           def main(args : Array[String]) : Unit =  
  23.           {  
  24.             if (args.length > 0)  
  25.               System.out.println("factorial " + args(0) +  
  26.                 " = " + factorial(new BigInteger(args(0))))  
  27.             else 
  28.               System.out.println("factorial 0 = 1")  
  29.           }  
  30.         }  
  31.       }  
  32.     }  
  33.   }  

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

清单 5. 批量导入

  1. package com  
  2. {  
  3.   package tedneward  
  4.   {  
  5.     package scala  
  6.     {  
  7.         // ...  
  8.    
  9.       package mathfun  
  10.       {  
  11.         object App  
  12.         {  
  13.           import java.math.BigInteger, BigInteger._  
  14.           
  15.           def factorial(arg : BigInteger) : BigInteger =  
  16.           {  
  17.             if (arg == ZERO) ONE  
  18.             else arg multiply (factorial (arg subtract ONE))  
  19.           }  
  20.           
  21.           def main(args : Array[String]) : Unit =  
  22.           {  
  23.             if (args.length > 0)  
  24.               System.out.println("factorial " + args(0) +  
  25.                 " = " + factorial(new BigInteger(args(0))))  
  26.             else 
  27.               System.out.println("factorial 0 = 1")  
  28.           }  
  29.         }  
  30.       }  
  31.     }  
  32.   }  

这样您可以节省一两行代码。注意这两个导入过程不能结合:先导入 BigInteger 类本身,再导入该类中的各种成员。

也可以使用 import 来引入其他非常量的成员。例如,考虑一下清单 6 中的数学工具库(或许不一定有什么价值):

清单 6. Enron 的记帐代码

  1. package com  
  2. {  
  3.   package tedneward  
  4.   {  
  5.     package scala  
  6.     {  
  7.         // ...  
  8.         
  9.       package mathfun  
  10.       {  
  11.         object BizarroMath  
  12.         {  
  13.           def bizplus(a : Int, b : Int) = { a - b }  
  14.           def bizminus(a : Int, b : Int) = { a + b }  
  15.           def bizmultiply(a : Int, b : Int) = { a / b }  
  16.           def bizdivide(a : Int, b : Int) = { a * b }  
  17.         }  
  18.       }  
  19.     }  
  20.   }  

使用这个库会越来越觉得麻烦,因为每请求它的一个成员,都需要键入 BizarroMath,但是 Scala 允许将 BizarroMath 的每一个成员导入最高层的词法空间,因此简直就可以把它们当成全局函数来使用(如清单 7所示):

清单 7. 计算 Enron的开支

  1. package com  
  2. {  
  3.   package tedneward  
  4.   {  
  5.     package scala  
  6.     {  
  7.       package demonstration  
  8.       {  
  9.         object App2  
  10.         {  
  11.           def main(args : Array[String]) : Unit =  
  12.           {  
  13.             import com.tedneward.scala.mathfun.BizarroMath._  
  14.               
  15.             System.out.println("2 + 2 = " + bizplus(2,2))  
  16.           }  
  17.         }  
  18.       }  
  19.     }  
  20.   }  

还有其他的一些构造很有趣,它们允许 Scala 开发人员写出更自然的 2 bizplus 2,但是这些内容本文不予讨论(想了解 Scala 潜在的可以用于其他用途的特性的读者可以看一下 Odersky、Spoon 和 Venners 所著的 Programming in Scala 中谈到的 Scala implicit 构造)。

#p#

访问

打包(和导入)是 Scala 封装的一部分,和在 Java 代码中一样,在 Scala 中,打包很大一部分在于以选择性方式限定访问特定成员的能力 — 换句话说,在于 Scala 将特定成员标记为 “公有(public)”、“private(私有)” 或介于两者之间的成员的能力。

Java 语言有四个级别的访问:公有(public)、私有(private)、受保护的(protected )和包级别(它没有任何关键词)访问。Scala:

废除了包级别的限制(在某种程度上)

默认使用 “公有”

指定 “私有” 表示 “只有此作用域可访问”

相反,Scala 定义 “protected” 的方式与在 Java 代码中不同;Java protected 成员对于子类和在其中定义成员的包来说是可访问的,Scala 中则仅有子类可访问。这意味着 Scala 版本的 protected 限制性要比 Java 版本更严格(虽然按理说更加直观)。

然而,Scala 真正区别于 Java 代码的地方是 Scala 中的访问修饰符可以用包名来 “限定”,用以表明直到 哪个访问级别才可以访问成员。例如,如果 BizarroMath 包要将成员访问权限授权给同一包中的其他成员(但不包括子类),可以用清单 8 中的代码来实现:

清单 8. Enron 的记帐代码

  1. package com  
  2. {  
  3.   package tedneward  
  4.   {  
  5.     package scala  
  6.     {  
  7.         // ...  
  8.         
  9.       package mathfun  
  10.       {  
  11.         object BizarroMath  
  12.         {  
  13.           def bizplus(a : Int, b : Int) = { a - b }  
  14.           def bizminus(a : Int, b : Int) = { a + b }  
  15.           def bizmultiply(a : Int, b : Int) = { a / b }  
  16.           def bizdivide(a : Int, b : Int) = { a * b }  
  17.       
  18.               private[mathfun] def bizexp(a : Int, b: Int) = 0 
  19.         }  
  20.       }  
  21.     }  
  22.   }  

注意此处的 private[mathfun] 表达。本质上,这里的访问修饰符是说该成员直到 包 mathfun 为止都是私有的;这意味着包 mathfun 的任何成员都有权访问 bizexp,但任何包以外的成员都无权访问它,包括子类。

这一点的强大意义就在于任何包都可以使用 “private” 或者 “protected” 声明甚至 com(乃至 _root_,它是根名称空间的别名,因此本质上 private[_root_] 等效于 “public” 同)进行声明。这使得 Scala 能够为访问规范提供一定程度的灵活性,远远高于 Java 语言所提供的灵活性。

实际上,Scala 提供了一个更高程度的访问规范:对象私有 规范,用 private[this] 表示,它规定只有被同一对象调用的成员可以访问有关成员,其他对象里的成员都不可以,即使对象的类型相同(这弥合了 Java 访问规范系统中的一个缺口,这个缺口除对 Java 编程问题有用外,别无他用。)

注意访问修饰符必须在某种程度上在 JVM 之上映射,这致使定义中的细枝末节会在从正规 Java 代码中调用或编译时丢失。例如,上面的 BizarroMath 示例(用 private[mathfun] 声明的成员 bizexp)将会生成清单 9 中的类定义(当用 javap 来查看时):

Listing 9. Enron 的记帐库,JVM 视图

  1. Compiled from "packaging.scala" 
  2. public final class com.tedneward.scala.mathfun.BizarroMath  
  3.    extends java.lang.Object  
  4. {  
  5.     public static final int $tag();  
  6.     public static final int bizexp(intint);  
  7.     public static final int bizdivide(intint);  
  8.     public static final int bizmultiply(intint);  
  9.     public static final int bizminus(intint);  
  10.     public static final int bizplus(intint);  

在编译的 BizarroMath 类的第二行很容易看出,bizexp() 方法被赋予了 JVM 级别的 public 访问修饰符,这意味着一旦 Scala 编译器结束访问检查,细微的 private[mathfun] 区别就会丢失。因此,对于那些要从 Java 代码使用的 Scala 代码,我宁愿坚持传统的 “private” 和 “public” 的定义(甚至 “protected” 的定义有时最终映射到 JVM 级别的 “public”,所有不确定的时候,请对照实际编译的字节码参考一下 javap,以确认其访问级别。)

#p#

应用

在本系列上一期的文章中(“集合类型”),当谈及 Scala 中的数组时(确切地说是 Array[T])我说过:“获取数组的第 i 个元素” 实际上是 “那些名称很有趣的方法中的一种……”。尽管当时是因为我不想深入细节,但不管怎么说事实证明这种说法严格来说 是不对的。

好吧,我承认,我说谎了。

技术上讲,在 Array[T] 类上使用圆括号要比使用 “名称有趣的方法” 复杂一点;Scala 为特殊的字符序列(即那些有左右括号的序列)保留了一个特殊名称关联,因为它有着特殊的使用意图 :“做”……(或按函数来说,将……“应用” 到……)。

换句话说,Scala 有一个特殊的语法(更确切一些,是一个特殊的语法关系)来代替 “应用” 操作符 “()”。更精确地说,当用 () 作为方法调用来调用所述对象时,Scala 将称为 apply() 的方法作为调用的方法。例如,一个想充当仿函数(functor)的类(一个充当函数的对象)可以定义一个 apply 方法来提供类似于函数或方法的语义:

清单 10. 使用 Functor!

  1. class ApplyTest  
  2. {  
  3.   import org.junit._, Assert._    
  4.     
  5.   @Test def simpleApply =  
  6.   {  
  7.     class Functor  
  8.     {  
  9.       def apply() : String =  
  10.       {  
  11.         "Doing something without arguments" 
  12.       }  
  13.         
  14.       def apply(i : Int) : String =  
  15.       {  
  16.         if (i == 0)  
  17.           "Done" 
  18.         else 
  19.           "Applying... " + apply(i - 1)  
  20.       }  
  21.     }  
  22.  
  23.     val f = new Functor  
  24.     assertEquals("Doing something without arguments", f() )  
  25.     assertEquals("Applying... Applying... Applying... Done", f(3))  
  26.   }  
  27. }  

好奇的读者会想是什么使仿函数不同于匿名函数或闭包呢?事实证明,它们之间的关系相当明显:标准 Scala 库中的 Function1 类型(指包含一个参数的函数)在其定义上有一个 apply 方法。快速浏览一些为 Scala 匿名函数生成的 Scala 匿名类,您就会明白生成的类是 Function1(或者 Function2 或 Function3,这要看该函数使用了几个参数)的后代。

这意味着当匿名的或者命名的函数不一定适合期望设计方法时,Scala 开发人员可以创建一个 functor 类,提供给它一些初始化数据,保存在字段中,然后通过 () 执行它,无需任何通用基类(传统的策略模式实现需要这个类):

清单 11. 使用 Functor!

  1. class ApplyTest  
  2. {  
  3.   import org.junit._, Assert._    
  4.  
  5.   // ...  
  6.     
  7.   @Test def functorStrategy =  
  8.   {  
  9.     class GoodAdder  
  10.     {  
  11.       def apply(lhs : Int, rhs : Int) : Int = lhs + rhs  
  12.     }  
  13.     class BadAdder(inflateResults : Int)  
  14.     {  
  15.       def apply(lhs : Int, rhs : Int) : Int = lhs + rhs * inflateResults  
  16.     }  
  17.  
  18.     val calculator = new GoodAdder  
  19.     assertEquals(4, calculator(22))  
  20.     val enronAccountant = new BadAdder(50)  
  21.     assertEquals(102, enronAccountant(22))  
  22.   }  
  23. }  

任何提供了被适当赋予了参数的 apply 方法的类,只要这些参数都按数字和类型排列了起来,它们都会在被调用时运行。

结束语

Scala 的打包、导入和访问修饰符机制提供了传统 Java 编程人员从未享受过的更高级的控制和封装。例如,它们提供了导入一个对象的选择方法的能力,使它们看起来就像全局方法一样,而且还克服了全局方法的传统的缺点;它们使得使用那些方法变得极其简单,尤其是当这些方法提供了诸如本系列早期文章(“Scala 控制结构内部揭密”)引入的虚构的 tryWithLogging 函数这样的高级功能时。

同样,“应用” 机制允许 Scala 隐藏函数部分的执行细节,这样,编程人员可能会不知道(或不在乎)他们正调用的东西 事实上不是一个函数,而是一个非常复杂的对象。该机制为 Scala 机制的函数特性提供了另一个方面,当然 Java 语言(或者 C# 或 C++)也提供了这个方面,但是它们提供的语法纯度没有 Scala 的高。

【相关阅读】

  1. Scala编程语言专题
  2. 面向Java开发人员的Scala指南:使用元组、数组和列表
  3. 面向Java开发人员的Scala指南:当继承中的对象遇到函数
  4. 面向Java开发人员的Scala指南:使用Scala版本的Java接口
  5. 面向Java开发人员的Scala指南:Scala控制结构内部揭密
责任编辑:yangsai 来源: IBMDW
相关推荐

2009-08-24 16:49:39

C#修饰符

2009-06-12 13:37:47

访问权限修饰符Java教程

2009-09-04 11:06:40

C#访问修饰符

2020-09-02 07:03:04

虚拟机HotSpotJava

2009-09-28 11:01:39

从Java走进Scal

2009-08-21 16:17:25

ScalaTwitter API

2009-07-22 08:45:35

Scala超类构造器override修饰符

2011-06-02 14:51:07

JAVA修饰符

2009-06-16 17:54:38

Scala类语法语义

2015-08-18 09:25:11

Java修饰符关键词

2009-06-17 13:57:25

Scala元组数组

2009-06-17 11:44:22

Scala控制结构

2021-11-21 22:36:18

Java修饰符开发

2009-06-12 14:46:05

static修饰符Java教程

2009-09-02 17:14:28

C#修饰符

2009-08-27 11:04:08

C# extern修饰

2009-08-27 13:06:13

C# new修饰符

2023-12-29 09:01:27

SwiftUI视图修饰符

2009-07-15 10:14:25

Scala并发性

2009-12-09 09:15:47

从Java走进ScalTwitter API
点赞
收藏

51CTO技术栈公众号