从Java走进Scala:面向对象的函数编程

开发 后端
在历史上,Java平台一直属于面向对象编程的领域,但是现在,甚至 Java 语言的坚定支持者也开始注意应用程序开发中的一种新趋势:函数编程。在这个新的系列中,Ted Neward 介绍了 Scala,一种针对 JVM 将函数和面向对象技术组合在一起的编程语言。在本文中,Ted 将举例说明您为何应该花时间学习 Scala(例如并发),并介绍如何快速从中受益。

您永远不会忘记您的初恋!

对于我来说,她的名字是 Tabinda (Bindi) Khan。那是一段愉快的少年时光,准确地说是在七年级。她很美丽、聪明,而最好的是,她常常因我的笨拙的笑话而乐不可支。在七年级和八年级的时间里,我们经常 “出去走走”(那时我们是这么说的)。但到了九年级,我们分开了,文雅一点的说法是,她厌倦了连续两年听到同样的笨拙的男孩笑话。我永远都不会忘记她(特别是因为我们在高中毕业 10 周年聚会时再次相遇);但更重要的是,我将永远不会失去这些珍贵的(也许有点言过其实)回忆。
 
Java 编程和面向对象是许多程序员的 “初恋”,我们对待它就像对待 Bindi 一样尊重和完全的爱慕。一些开发人员会告诉您 Java 将他们从内存管理和 C++ 的炼狱中解救出来了。其他一些人会告诉您 Java 编程使他们摆脱了对过程性编程的绝望。甚至对于一些开发人员来说,Java 代码中的面向对象编程就是 “他们做事情的方式”。(嘿嘿,如果这对我爸爸,以及爷爷有用该多好!)

然而,时间最终会冲淡所有对初恋的记忆,生活仍然在继续。感情已经变了,故事中的主角也成熟了(并且学会了一些新笑话)。但最重要的是,我们周围的世界变了。许多 Java 开发人员意识到尽管我们深爱 Java 编程,但也应该抓住开发领域中的新机会,并了解如何利用它们。

我将始终爱着你 ……

在最近五年中,对 Java 语言的不满情绪逐渐增多。尽管一些人可能认为 Ruby on Rails 的发展是主要因素,但是我要争辩的是,RoR(被称为 Ruby 专家)只是结果,而非原因。或者,可以更准确地说,Java 开发人员使用 Ruby 有着更深刻、更隐伏的原因。

简单地说,Java 编程略显老态了。

或者,更准确地说,Java 语言 略显老态了。

考虑一下:当 Java 语言最初诞生时,Clinton(第一位)在办公室中,很少有人使用 Internet,这主要是因为拨号是在家里使用网络的惟一方式。博客还没有发明出来,每个人相信继承是重用的基本方法。我们还相信,对象是为对世界进行建模的最好方法,摩尔定律将永远统治着世界。

实际上,摩尔定律引起了行业内许多人的特别关注。自 2002/2003 年以来,微处理器技术的发展使得具有多个 “内核” 的 CPU 得以创造出来:本质上是一个芯片内具有多个 CPU。这违背了摩尔定律,摩尔定律认为 CPU 速度将每隔 18 个月翻一倍。在两个 CPU 上同时执行多线程环境,而不是在单个 CPU 上执行标准循环周期,这意味着代码必须具有牢固的线程安全性,才能存活下来。

学术界已经展开了围绕此问题的许多研究,导致了过多新语言的出现。关键问题在于许多语言建立在自己的虚拟机或解释器上,所以它们代表(就像 Ruby 一样)到新平台的转换。并发冲突是真正的问题所在,一些新语言提供了强大的解决方案,太多的公司和企业对 10 年前从 C++ 到 Java 平台的迁移仍记忆犹新。许多公司都不愿意冒迁移到新平台的风险。事实上,许多公司对上一次迁移到 Java 平台仍心有余悸。

了解 Scala。

一种可伸缩语言

Scala 是一种函数对象混合的语言,具有一些强大的优点:

首先,Scala 可编译为 Java 字节码,这意味着它在 JVM 上运行。除了允许继续利用丰富的 Java 开源生态系统之外,Scala 还可以集成到现有的 IT 环境中,无需进行迁移。
其次,Scala 基于 Haskell 和 ML 的函数原则,大量借鉴了 Java 程序员钟爱的面向对象概念。因此,它可以将两个领域的优势混合在一起,从而提供了显著的优点,而且不会失去我们一直依赖的熟悉的技术。
最后,Scala 由 Martin Odersky 开发,他可能是 Java 社区中研究 Pizza 和 GJ 语言的最著名的人,GJ 是 Java 5 泛型的工作原型。而且,它给人一种 “严肃” 的感觉;该语言并不是一时兴起而创建的,它也不会以同样的方式被抛弃。
Scala 的名称表明,它还是一种高度可伸缩 的语言。我将在本系列的后续文章中介绍有关这一特性的更多信息。

下载并安装 Scala

可以从 Scala 主页 下载 Scala 包。截止到撰写本文时,最新的发行版是 2.6.1-final(51CTO编者注:现在已经是2.7.5版)。它可以在 Java 安装程序版本 RPM 和 Debian 软件包 gzip/bz2/zip 包中获得,可以简单地将其解压到目标目录中,而且可以使用源码 tarball 从头创建。(Debian 用户可以使用 “apt-get install” 直接从 Debian 网站上获得 2.5.0-1 版。2.6 版本具有一些细微的差异,所以建议直接从 Scala 网站下载和安装。)

将 Scala 安装到所选的目标目录中 — 我是在 Windows® 环境中撰写本文的,所以我的目标目录是 C:/Prg/scala-2.6.1-final。将环境变量 SCALA_HOME 定义为此目录,将 SCALA_HOME\bin 放置于 PATH 中以便从命令行调用。要测试安装,从命令行提示符中激发 scalac -version。它应该以 Scala 版本 2.6.1-final 作为响应。

#p#

函数概念

开始之前,我将列出一些必要的函数概念,以帮助理解为何 Scala 以这种方式操作和表现。如果您对函数语言 — Haskell、ML 或函数领域的新成员 F# — 比较熟悉,可以 跳到下一节。

函数语言的名称源于这样一种概念:程序行为应该像数学函数一样;换句话说,给定一组输入,函数应始终返回相同的输出。这不仅意味着每个函数必须返回一个值,还意味着从一个调用到下一个调用,函数本质上不得具有内蕴状态(intrinsic state)。这种无状态的内蕴概念(在函数/对象领域中,默认情况下指的是永远不变的对象),是函数语言被认为是并发领域伟大的 “救世主” 的主要原因。

与许多最近开始在 Java 平台上占有一席之地的动态语言不同,Scala 是静态类型的,正如 Java 代码一样。但是,与 Java 平台不同,Scala 大量利用了类型推断(type inferencing),这意味着,编译器深入分析代码以确定特定值的类型,无需编程人员干预。类型推断需要较少的冗余类型代码。例如,考虑声明本地变量并为其赋值的 Java 代码,如清单 1 所示:

清单 1. 声明本地变量并为其赋值的 Java 代码

  1. class BrainDead {  
  2.   public static void main(String[] args) {  
  3.     String message = "Why does javac need to be told message is a String?" +  
  4.       "What else could it be if I'm assigning a String to it?";  
  5.   }  

Scala 不需要任何这种手动操作,稍后我将介绍。

大量的其他函数功能(比如模式匹配)已经被引入到 Scala 语言中,但是将其全部列出超出了本文的范围。Scala 还添加许多目前 Java 编程中没有的功能,比如操作符重载(它完全不像大多数 Java 开发人员所想象的那样), 具有 “更高和更低类型边界” 的泛型、视图等。与其他功能相比,这些功能使得 Scala 在处理特定任务方面极其强大,比如处理或生成 XML。

但抽象概述并不够:程序员喜欢看代码,所以让我们来看一下 Scala 可以做什么。

开始认识您

根据计算机科学的惯例,我们的第一个 Scala 程序将是标准的演示程序 “Hello World”:

清单 2. Hello.Scala

  1. object HelloWorld {  
  2.   def main(args: Array[String]): unit = {  
  3.     System.out.println("Hello, Scala!")  
  4.   }  

使用 scalac Hello.scala 编译此程序,然后使用 Scala 启动程序(scala HelloWorld)或使用传统的 Java 启动程序运行生成的代码,注意,将 Scala 核心库包括在 JVM 的类路径(java -classpath %SCALA_HOME%\lib\scala-library.jar;. HelloWorld)中。不管使用哪一种方法,都应出现传统的问候。

清单 2 中的一些元素对于您来说一定很熟悉,但也使用了一些新元素。例如,首先,对 System.out.println 的熟悉的调用演示了 Scala 对底层 Java 平台的忠诚。Scala 充分利用了 Java 平台可用于 Scala 程序的强大功能。(事实上,它甚至会允许 Scala 类型继承 Java 类,反之亦然,但更多信息将在稍后介绍。)

另一方面,如果仔细观察,您还会注意到,在 System.out.println 调用的结尾处缺少分号;这并非输入错误。与 Java 平台不同,如果语句很明显是在一行的末尾终结,则 Scala 不需要分号来终结语言。但是,分号仍然受支持,而且有时候是必需的,例如,多个语句出现在同一物理行时。通常,刚刚入门的 Scala 程序员不用考虑需不需加分号,当需要分号的时候,Scala 编译器将提醒程序员(通常使用闪烁的错误消息)。

此外,还有一处微小的改进,Scala 不需要包含类定义的文件来反映类的名称。一些人将发现这是对 Java 编程的振奋人心的变革;那些没有这样做的人可以继续使用 Java “类到文件” 的命名约定,而不会出现问题。

现在,看一下 Scala 从何处真正脱离传统的 Java/面向对象代码。

将函数和表单最终结合起来

对于初学者,Java 发烧友将注意到,HelloWorld 是使用关键字 object 来定义的,而不是使用 class。这是 Scala 对单例模式(Singleton pattern)的认可 — object 关键字告诉 Scala 编译器这将是个单例对象,因此 Scala 将确保只有一个 HelloWorld 实例存在。基于同样的原因,注意 main 没有像在 Java 编程中一样被定义为静态方法。事实上,Scala 完全避开了 static 的使用。如果应用程序需要同时具有某个类型的实例和某种 “全局” 实例,则 Scala 应用程序将允许以相同的名字同时定义 class 和 object。

接下来,注意 main 的定义,与 Java 代码一样,是 Scala 程序可接受的输入点。它的定义,虽然看起来与 Java 的定义不同,实际上是等同的:main 接受 String 数组作为参数且不返回任何值。但是,在 Scala 中,此定义看起来与 Java 版本稍有差异。args 参数被定义为 args: Array[String]。

在 Scala 中,数组表示为泛型化的 Array 类的实例,这正是 Scala 使用方括号(“[]”)而非尖括号(“<>”)来指明参数化类型的原因。此外,为了保持一致性,整个语言中都使用 name: type 的这种模式。

与其他传统函数语言一样,Scala 要求函数(在本例中为一个方法)必须始终返回一个值。因此,它返回称为 unit 的 “无值” 值。针对所有的实际目的,Java 开发人员可以将 unit 看作 void,至少目前可以这样认为。

方法定义的语法似乎比较有趣,当它使用 = 操作符时,就像将随后的方法体赋值给 main 标识符。事实上,真正发生的事情是:在函数语言中,就像变量和常量一样,函数是一级概念,所以语法上也是一样地处理。

您说的是闭包吗?

函数作为一级概念的一个含义是,它们必须被识别为单独的结构,也称为闭包,这是 Java 社区最近一直热烈争论的话题。在 Scala 中,这很容易完成。考虑清单 3 中的程序,此程序定义了一个函数,该函数每隔一秒调用一次另一个函数:

清单 3. Timer1.scala

  1. object Timer  
  2. {  
  3.   def oncePerSecond(): unit =  
  4.   {  
  5.     while (true)  
  6.     {  
  7.       System.out.println("Time flies when you're having fun(ctionally)...")  
  8.       Thread.sleep(1000)  
  9.     }  
  10.   }  
  11.  
  12.   def main(args: Array[String]): unit =  
  13.   {  
  14.     oncePerSecond  
  15.   }  
  16. }  

不幸的是,这个特殊的代码并没有什么功能 …… 或者甚至没任何用处。例如,如果想要更改显示的消息,则必须修改 oncePerSecond 方法的主体。传统的 Java 程序员将通过为 oncePerSecond 定义 String 参数来包含要显示的消息。但甚至这样也是极端受限的:其他任何周期任务(比如 ping 远程服务器)将需要各自版本的 oncePerSecond,这很明显违反了 “不要重复自己” 的规则。我认为我可以做得更好。

清单 4. Timer2.scala

  1. object Timer  
  2. {  
  3.   def oncePerSecond(callback: () => unit): unit =  
  4.   {  
  5.     while (true)  
  6.     {  
  7.       callback()  
  8.       Thread.sleep(1000)  
  9.     }  
  10.   }  
  11.  
  12.   def timeFlies(): unit =   
  13.   { Console.println("Time flies when you're having fun(ctionally)..."); }  
  14.  
  15.   def main(args: Array[String]): unit =  
  16.   {  
  17.     oncePerSecond(timeFlies)  
  18.   }  
  19. }  

现在,事情开始变得有趣了。在清单 4 中,函数 oncePerSecond 接受一个参数,但其类型很陌生。形式上,名为 callback 的参数接受一个函数作为参数。只要传入的函数不接受任何参数(以 () 指示)且无返回(由 => 指示)值(由函数值 unit 指示),就可以使用此函数。然后请注意,在循环体中,我使用 callback 来调用传递的参数函数对象。

幸运的是,我在程序的其他地方已经有了这样一个函数,名为 timeFlies。所以,我从 main 中将其传递给 oncePerSecond 函数。(您还会注意到,timeFlies 使用了一个 Scala 引入的类 Console,它的用途与 System.out 或新的 java.io.Console 类相同。这纯粹是一个审美问题;System.out 或 Console 都可以在这里使用。)

#p#

匿名函数,您的函数是什么?

现在,这个 timeFlies 函数似乎有点浪费 — 毕竟,它除了传递给 oncePerSecond 函数外毫无用处。所以,我根本不会正式定义它,如清单 5 所示:

清单 5. Timer3.scala

  1. object Timer  
  2. {  
  3.   def oncePerSecond(callback: () => unit): unit =  
  4.   {  
  5.     while (true)  
  6.     {  
  7.       callback()  
  8.       Thread.sleep(1000)  
  9.     }  
  10.   }  
  11.  
  12.   def main(args: Array[String]): unit =  
  13.   {  
  14.     oncePerSecond(() =>   
  15.       Console.println("Time flies... oh, you get the idea."))  
  16.   }  
  17. }   

在清单 5 中,主函数将一块任意代码作为参数传递给 oncePerSecond,看起来像来自 Lisp 或 Scheme 的 lambda 表达式,事实上,这是另一种闭包。这个匿名函数 再次展示了将函数当作一级公民处理的强大功能,它允许您在继承性以外对代码进行全新地泛化。(Strategy 模式的粉丝们可能已经开始唾沫横飞了。)

事实上,oncePerSecond 仍然太特殊了:它具有不切实际的限制,即回调将在每秒被调用。我可以通过接受第二个参数指明调用传递的函数的频率,来将其泛化,如清单 6 所示:

清单 6. Timer4.scala

  1. object Timer  
  2. {  
  3.   def periodicCall(seconds: int, callback: () => unit): unit =  
  4.   {  
  5.     while (true)  
  6.     {  
  7.       callback()  
  8.       Thread.sleep(seconds * 1000)  
  9.     }  
  10.   }  
  11.  
  12.   def main(args: Array[String]): unit =  
  13.   {  
  14.     periodicCall(1, () =>   
  15.       Console.println("Time flies... oh, you get the idea."))  
  16.   }  
  17. }   

这是函数语言中的公共主题:创建一个只做一件事情的高级抽象函数,让它接受一个代码块(匿名函数)作为参数,并从这个高级函数中调用这个代码块。例如,遍历一个对象集合。无需在 for 循环内部使用传统的 Java 迭代器对象,而是使用一个函数库在集合类上定义一个函数 — 通常叫做 “iter” 或 “map” — 接受一个带单个参数(要迭代的对象)的函数。例如,上述的 Array 类具有一个函数 filter,此函数在清单 7 中定义:

清单 7. Array.scala 的部分清单

  1. class Array[A]  
  2. {  
  3.     // ...  
  4.    def filter  (p : (A) => Boolean) : Array[A] = ... // not shown  

清单 7 声明 p 是一个接受由 A 指定的泛型参数的函数,然后返回一个布尔值。Scala 文档表明 filter “返回一个由满足谓词 p 的数组的所有元素组成的数组”。这意味着如果我想返回我的 Hello World 程序,查找所有以字母 G 开头的命令行参数,则可以编写像清单 8 一样简单的代码:

清单 8. Hello, G-men!

  1. object HelloWorld  
  2. {  
  3.   def main(args: Array[String]): unit = {  
  4.     args.filter( (arg:String) => arg.startsWith("G") )  
  5.         .foreach( (arg:String) => Console.println("Found " + arg) )  
  6.   }  

此处,filter 接受谓词,这是一个隐式返回布尔值(startsWith() 调用的结果)的匿名函数,并使用 args 中的每个元素来调用谓词。如果谓词返回 true,则它将此值添加到结果数组中。遍历了整个数组之后,它接受结果数组并将其返回,然后此数组立即用作 “foreach” 调用的来源,此调用执行的操作就像它名字的含义一样:foreach 接受另一个函数,并将此函数应用于数组中的每个元素(在本例中,仅显示每个元素)。

不难想象等同于上述 HelloG.scala 的 Java 是什么样的,而且也不难发现 Scala 版本非常简短,也非常清晰。

结束语

Scala 中的编程如此地熟悉,同时又如此地不同。相似之处在于您可以使用已经了解而且钟爱多年的相同的核心 Java 对象,但明显不同的是考虑将程序分解成部分的方式。在面向 Java 开发人员的 Scala 指南 的第一篇文章中,我仅仅简单介绍了 Scala 的功能。将来还有很多内容尚待挖掘,但是现在让我们陶醉在函数化的过程中吧!

【相关阅读】

  1. Scala编程语言专题
  2. Scala的类型系统:取代复杂的通配符
  3. Scala的类型系统 比Java更灵活
  4. Java程序员,你为什么要关注Scala
  5. Scala创始人:创造比Java更好的语言
责任编辑:yangsai 来源: IBMDW
相关推荐

2009-06-17 13:26:06

scala继承模型

2010-11-17 11:31:22

Scala基础面向对象Scala

2009-07-08 16:10:24

Scala简介面向对象函数式

2009-09-28 11:01:39

从Java走进Scal

2009-08-21 16:17:25

ScalaTwitter API

2011-06-28 11:06:16

Scala

2009-12-09 09:15:47

从Java走进ScalTwitter API

2009-06-17 11:44:22

Scala控制结构

2009-10-14 11:14:38

ScitterScalaTwitter

2009-06-16 17:54:38

Scala类语法语义

2009-07-15 10:14:25

Scala并发性

2009-02-04 17:32:03

ibmdwJavaScala

2010-03-11 10:34:22

Scala

2009-09-27 15:29:00

Scala讲座面向对象Scala

2009-06-17 13:57:25

Scala元组数组

2011-05-25 11:15:02

Javascript继承

2009-06-19 10:51:39

Scalapackage访问修饰符

2009-08-14 11:35:01

Scala Actor

2020-10-26 12:27:18

对象编程函数式

2011-07-05 14:42:46

java
点赞
收藏

51CTO技术栈公众号