Scala—Java的避难所：第一部分：main(String[])

注意:因为本文使用的Scala版本较老，部分内容已经不适用于当前Scala版本（比如关于"+="运算符的优先级）。2010.1.4

引用

前言: 本文是Scala--Java的避难所的第一部分.也是我学习Scala时认真阅读的第一份资料.我把它翻译过来,方便那些对Scala感兴趣的Javaer看.我尽量按原文的意思翻译(考虑到我的英语水平,你不必对这话太当真^_^).但原文某些地方我加上了自己的解释或看法,一律以译者注标明.
　　另外,对于标题取为"Scala—JAVA的避难所"其实我并不感冒.但原文是这样,我也就这样翻译了.

　　你可能已经使用JAVA若干年了,或许JAVA是你接触编程来的第一门编程语言,或许是作为比C++更好的一个选择.不管怎么样,你已经适应了JAVA,并了解她的外观与内在,能够体会它的喜怒与哀乐(原文:You’re comfortable with Java, you know its ins and outs, its moods).她就像你相处多年的女朋友,或许刚相识时那种激情已经不再,但你已经熟悉怎样才能让她开心.简单的说,如果你是一位工匠,则JAVA就是你干活的工具.
　　然而,你和JAVA的蜜月期过去了,你在编程语言的选择上更加务实了.只要有足够的理由,你就可以毫不犹豫去尝试一种新的语言,但JAVA还没有足够的缺陷让你下定决心离开她.此时,你听说了一个叫做Ruby的东东,它的简洁优雅以及巨大的威力给你留下深刻的印象.但你并不是那么确定去使用一个脚步语言来构建你的企业应用.动态类型以及TextMate确实都不错,但对于现实世界,你需要一个更坚实的支柱.作为一个实用主义者,你仍然坚持使用JAVA.
　　这时,好消息传来了.一门新的编程语言登上了舞台并在开发者的世界引起了一场风暴.Scala貌似具有你对一门编程语言所期待一切: 静态类型,编译为字节码,简洁且富有表现力的语法.你可能已经被它的一些例子给深深吸引了.它看起来和JAVA非常相似,但是剔除了JAVA中冗余的语法结构.Scala没有分号,没有public static void的方法修饰词,并且具有静态类型推断机制.
　　现在剩下的唯一问题就是你应该从何开始.你也许尝试过去Scala的网站查看相关知识,但是..这一切看起来是那么的函数化:Lamdas,high-order functions,immutable state,recursion out the wazoo.突然让人感到前途未卜.
　　但是,JavaEE的难民们,不必担心.Scala确实是一门函数式的编程语言,但它同样也是命令式的和面向对象的.也就是说,除了书写那种晦涩难懂的函数式代码(原文: It means that you don’t have to write code with the sole purpose of pleasing Haskell Curry. ),你还有其它的选择.你可以书写可读性很强的代码,以便你一个星期之后还能看懂它.将你的代码给你那些只使用JAVA的同事看,他们甚至也能看懂它.只需要一个正确的引导,你就可以使用Scala来构建你的的JAVA应用.

导读:
　　如果符合上面所说的,那么这个Scala系列就是为你而准备的.我已经阅读过大量有关Scala的文章以及入门材料(如果你更喜欢函数式的编程,我强烈推荐你去看Alex Blewitt写的系列文章),但很少有文章是为了使JAVA开发比较轻松的转变到Scala来的.我个人缺乏FP(函数式编程)的经验,因此我肯定不会在文章中介绍如何将Scheme代码移植到Scala.该系列文章着重于类比Scala与JAVA,并说明为什么Scala比JAVA更好.

起步:

object HelloWorld extends Application{
    println("Hello, World!")
}

　　没有什么比用代码来获得知识更直接了,注意到上面的代码没有使用分号.当然,如果你愿意还是可以像在JAVA中一样使用它.但除非你想在同一行中书写多个语句,否则分号不是必须的.这个代码示例含义非常清楚,想必你已经看明白了它的功能.没错,就是向标准控制台输出一行"Hello, World!".你可以将这些代码保存到一个后缀名为scala的文件中,然后使用scala编译器编译它,编译的结果是一个单独的class文件(译者注:这里原文似乎有错,我编译后事实上生成了两个class文件).你可以像运行普通java文件那样使用java解释器来运行它,不过你需要注意一下classpath.最直接的方法是使用scala命令:

引用

scalac hello.scala
scala HelloWorld

　　注意到"hello.scala"文件名没有?Scala并不像Java一样强制你在定义public class时,必须保存在文件名与类名相同的文件中.事实上Scala允许你像C++或Ruby一样,在同一个文件中你想定义多少class都可以.但我们最好还是遵循Java的命名规则,因此作为一个具有良好习惯的程序员,我们应该将上面的代码保存为"HelloWorld.scala".

编辑器:
　　在刚开始接触Scala,选择一个正确的编辑器是个关键.就像你在使用Java中所了解的那样,IDE非常有用.但作为一门新生的编程语言,Scala目前还没有很好的IDE支持,不过这只是时间问题.在目前,你只有非常有限的选择:

引用

Eclipse(有几个不太成熟的Scala插件)
Emacs
IntelliJ(只支持基本的语法高亮)
TextMate
VIM
jEdit

(译者注:我使用的是UltraEdit,自己配置一下,能够自动缩进与语法高亮以及编译运行,凑合着用了)
　　上面列的是几个主要的选项,更完整的列表可以去Scala安装目录下的misc/scala-tool-support/文件夹下查看.我个人推荐使用jEidt或者TextMate;如果你有冒险精神,可以去尝试Eclipse上的几个插件.Eclipse上的插件具有通常IDE所具有的一些功能(至少Beta版是这样),譬如语义高亮,代码自动完成,etc.但根据我的经验,这些插件都不够稳定以至于难以使用.Scala是一门比Java简洁多的语言,它对IDE的依赖性比Java小得多,因此这些都不是本质问题,你可以照样做的很好.

　　再来一个例子

object HelloWorld2{
    def main(args:Array[String]) = {
       var greeting =""
       for(i <- 0 until args.length){
           greeting += (args(i) + " ")        
       }
       if(args.length > 0) greeting =greeting.substring(0, greeting.length -1 )
       
       println(greeting)
    }
}

(译者注: 可能有读者会奇怪greeting += (args(i) + " ")这段代码为什么要用括号,注意,虽然与习惯不同,但这里的括号是必须的.因为在Scala里面,运算符的优先级由运算符第一个字符代表的运算符的优先级确定.就是说"+="的优先级与"+"的优先级一样,然后..自己想吧:-).BTW,Scala里的运算符也是方法&对象..)
　　将它保存到HelloWorld2.scala,并使用如下命令编译运行:

引用

scalac HelloWorld2.scala
scala HelloWorld2 Hello, World!

　　这次我们使用了不同的方式,通过命令行向程序传递参数,其运行的结果同样是在控制台输出"Hello, World".这个程序比上一个复杂一些,首先定义了一个String类型的变量greeting,然后遍历一个数组,最后对String进行适当的处理(Scala专家肯定会建议使用Array#deepMkString(String)(类似于Ruby中的Array::join方法),这样确实没错.但我这里主要是为了介绍一些语言上的知识,而不是API的使用).

　　首先应该注意的是,这里我们定义了一个main方法.在第一个例子中,我们仅仅继承了Application类,然后把其它的都交给默认构造函数来做.这样很好很简洁,但有两个问题:第一,我们没有办法向程序传递命令行参数;第二,对Scala新手来说,这样看起来有点魔幻.我将在后面的文章中揭开第一个例子中背后的把戏,现在你记住它就是了.
　　这个例子中的main方法是不是已经让你联想到了JAVA中的 public static void main?没错,Scala中的main就对应Java中的 public static void main.根据这个信息,有经验的程序员就可以通过思考知道更多关于Scala的知识.
　　一开始,你可能有这样的结论:Scala中的方法隐含就是public的.这基本正确,Scala中的方法默认为public,这意味着Scala中没有public方法修饰词(private与protected都有定义).更进一步的,你会猜测:Scala中的方法默认为static的.然而,这次你的猜想不完全正确.
　　Scala并没有真正意义上的static属性.你越早认识到这一点,你就越容易理解这门语言.作为替代,Scala有专门的语法让你实现与使用sigleton模式(这正是object的含义).我们实际上声明了一个具有实例方法main(译者注:注意,这个main方法并不是static的)的单实例类(singleton class).我将会在以后详细说明这一点,目前你可以认为object就是一个只具有静态方法的类.(译者注:这个描述不甚准确).
　　仔细的观察这个例子,我们还可以得到Scala中数组的语法,以及如何显式的指明一个变量的类型.让我们仔细研究一下声明main方法的这行代码:

def main(args:Array[String]) = {

　　这儿,args是一个Array[String]类型的方法参数.也就是说,args是一个String数组.在Scala中,Array是一个具有类型参数指明其元素类型的类(一个真正的类,而不是JAVA中那样).与之对等的JAVA语法应该类似与下面这样子(假设Java中也有一个Array类):

public static void main(Array<String> args)

　　在Scala中,使用variable:Type的语法来指明变量类型.因此,如果我们想显式声明一个Int类型的变量,应该通过如下方式

var myInteger:Int

　　在例子中,我们实际上声明了一个String类型的变量greeting.然而,得益于Scala中的类型推断机制,我们并没有显式指明变量的类型.下面两种方式在语义上是等价的:

var greeting =""

var greeting:String =""

　　在第一种方式中,我们显然知道greeting是一个String,Scala编译器也能够推断出这一点.这两个变量都是静态类型检查的,只不过第一种方式可以少写7个字符:-)
细心的读者可能还注意到了,例子中的main方法并没有指明返回类型.这是因为Scala同样可以推断出来.如果我们想显式的指明这点,可以像下面这样:

def main(args:Array[String]):Unit = {

　　如前面一样,类型在方法名之后,并用冒号隔开.顺便提一下,Unit是Scala中的一个类型,它表示"我不关心返回的究竟是什么东东"(原文:I-really-don't-care-what-I-return),你可以把它想象为JAVA中void类型与对象的混合物(译者注:但Unit不是void,而是一个实实在在的类,也就是说Unit类型的方法会返回一个Unit对象).

数组的遍历:

var greeting =""
for(i <- 0 until args.length) {
    greeting += (args(i) + " ")
}

(译者注: 目前Scala中这种方式遍历的性能相对低下,速度大概是JAVA中对应for的1/60.这个其实也不会造成太大的影响,因为耗时一般不在于for循环本身,而是循环体内的操作.更何况在Scala中用for的机会不多,有更多简单实用的方式去实现同样的操作)

　　这段代码比刚才那段稍微复杂点.我们一开始声明了一个String类型的变量greeting,然后使用了一个在Scala中不常用的for循环,这里有一些隐含的类型推断.有Ruby经验的知道在Ruby中的等价形式:

for i in 0..(args.size - 1)
  greeting += args[i] + " "
end

　　问题的关键在于,Scala的for循环语句需要一个Range对象,而这个Range对象是由RichInt的until方法建立的.我们可以把上面的代码分开写:

val range =0.until(args.length)
for(i <- range) {

　　注意,这里使用"val"而不是"var"声明变量.使用val,就如java中final的语义,指明range是一个常量.
　　在Scala中,我们可以通过多种不同的形式调用方法.在这个例子中,我们看到了"value methodName param"与"value.methodName(param)"这两种形式的语法是等价的.另外一个很重要的事情是,until方法是RichInt具有的,Int并没有该方法.这里存在一个隐式类型转换,将Int类型的0转换为scala.runtime.RichInt的一个实例.这里不去深究这个类型转换是怎样进行的,我们关心的是RichInt类确实有一个返回Rangle对象的until方法.
因此,事实上这段代码与JAVA中的下列代码在逻辑上是等价的:

for (int i = 0; i < args.length; i++) {

　　只不过在JAVA中是显式的遍历整个区间,而Scala中使用了一个Range对象.
可能你还注意到了,循环体中访问数组args元素使用的是圆括号"()",而不是我们习惯的方括号"[]".

更好的遍历方式:
　　在JAVA 5中引入了一个foreach的语法,像下面这样:

for(String arg: args) {
    greeting += arg + " ";
}

　　这样更简洁明了.Scala中使用高阶函数(使用函数做参数的函数)实现类似的功能:

args.foreach {arg =>
    greeting += (arg + " ")
}

　　我们可以看到,Array类有一个foreach方法,这个方法将一个函数作为参数.foreach方法将会对Array里的每一个元素调用一次这个函数,并在调用的时候将这个元素作为函数参数传递给函数.这里参数arg没有指明类型,但由于我们是对一个String数组遍历,编译器能推断出它的类型是String.我们已经提到过,Scala中调用方法有多钟不同的方式.这里我们就省略了圆括号"()",同样我们也可以写成:

args.foreach(arg => {
  greeting += (arg + " ")
})

　　Scala中我们可以使用更加简洁的书写方式:

args.foreach(arg => greeting +=(arg + " "))

　　不错吧,现在我们将整个例子重写成:

object HelloWorld2 {
  def main(args:Array[String]) = {
    var greeting = ""
    args.foreach(arg => greeting += (arg + " "))
    if (args.length > 0) greeting = greeting.substring(0, greeting.length - 1)
 
    println(greeting)
  }
}

Scala的内置类型:
　　因为Scala是基于JVM的,因此它从JAVA那儿继承了大量的API.这意味这你能够与JAVA交互使用.并且,你所写的Scala代码事实上使用的就是Java API.比如上面的HelloWorld2中我们使用了一个字符串变量greeting,这个变量事实上就是Java中的String类型.再比如,当你在Scala中声明一个整数类型(Int),编译器会自动将它转换为Java的基本类型int.
　　Scala还内置了一些隐式类型转换,当需要的时候编译器会自动进行(就像例子中的Int到RichInt类型的转换).比如在Scala中将Array[String]类型传递给需要String[]类型参数的函数时,隐式类型转换就会发生.甚至Scala中的类型参数可以和Java中的泛型相互转化.简单的说,Scala就是一个披着不同语法外衣的Java.

结束
　　Scala不需要复杂高深的理论或学术知识.一个普通的开发者就可以在下一个企业WEB应用里面使用它.它具有JAVA所缺乏的简洁明了的语法,并且保留了JAVA的高效与可靠性.

译者注:本文中的HelloWorld2还有一下一些版本

object HelloWorld{
	def main(args: Array[String]) {
		println(args.mkString(" "))
	}
}

object HelloWorld{
	def main(args: Array[String]) {
		println(args.reduceLeft((a:String,b:String)=>a+" "+b))
	}
}

object HelloWorld{
	def main(args: Array[String]) {
		println(args.reduceLeft[String](_+" "+_))
	}
}

评论

22 楼 孤灯渡漠 2009-01-22  

此帖很精啊，正在学习scala，刚开始看

21 楼 rmn190 2008-12-26  

有没有人用这个Scala做过项目?

能不能谈谈项目中的感受?

20 楼 Eastsun 2008-04-16  

williamy 写道

灵活的语法，我无法用好，于是我喜欢死板的语法
并且我花时间去理解一套灵活的语法，换来的是程序性能的地下，稳定性的缺失！那肯定是生病了后的行为

呵呵,这个和实际需求有关.
最高效与简单的语言莫过于汇编了(我玩过80x86与6502汇编),但除非特定的情形,否则很少有人愿意使用汇编来写程序吧.
对于WEB开发,很多时候程序的性能不是最重要的.

19 楼 williamy 2008-04-16  

灵活的语法，我无法用好，于是我喜欢死板的语法
并且我花时间去理解一套灵活的语法，换来的是程序性能的地下，稳定性的缺失！那肯定是生病了后的行为

18 楼 williamy 2008-04-16  

我的建议是：
1，如果我是刚毕业的，我什么都没学，那么我选择Java，
能够快速搞定问题，快速学会它 ，快速靠它找个工作
2.如果我不想找工作，但是我喜欢程序，于是我选择C
3.如果我不想找工作，同时我不喜欢程序，于是我选择basketball/football
4.如果我会C了，我想再学一个，那么选择D
5.如果我会java了，我想再学一个，那么选择Groovy
6.如果我只会ruby，我想再学一个，那么学日语

17 楼 williamy 2008-04-16  

再强调一遍，Tibco编程语言排名，我估计永远都是C第一，当然，如果硬件变化了，我就不知道了

16 楼 williamy 2008-04-16  

这个叫做pre-Build
你看scalac调用的是tool。。。。Main  意思是call了jar里的Main。class，而这个class是哪里来的，可以看到source里有Main。scala
你缺省的部分代码，其实已经Pre-Build了，前一些时间作者告诉我说最开始是Pico写的编译器，嘿嘿，同样你说的Jline,我没自己看，你找不到，那就是PreBuild了
Java的编译器，现在也是Java写的，都一样的概念，所以说Scala语言很一般，我认为是民间的一种对Java本身太死板的一种反馈，希望在语法上改进Java，
却不知道现在最大的语言群体是C，是最死板的东西啦，特别是有些只玩Java的人，把tibco的排名拿出来！看看开源世界里，java的开源项目一点都没有影响力

15 楼 williamy 2008-04-16  

我学了scala，现在在看compiler，
我知道我错了，我浪费了时间
（我个人看法）

14 楼 williamy 2008-04-16  

你可能是因为Scala Actor而去学Scala的,
如果你考虑到以后JVM本身就为你处理了这些,请问难道Actor还有存在的意义吗?
我们的程序是JVM上跑的,如果推出JVM7,请问你还用JVM6吗?

所以,SUN都不支持,
SUN有自己一套和Google的MapReducer一个意义的新FP语言
看欧洲几个人搞的东西，没多大前途的

13 楼 Eastsun 2008-04-16  

呵呵,看来对Scala感冒的人不多.
不知道熟悉FP的人对Scala是何看法.

12 楼 AllenZhang 2008-04-16  

“但是剔除了JAVA中冗余的语法结构.Scala没有分号,没有public static void的方法修饰词。。。”
说实话，我觉得这些关键字蛮实用的。也没有觉得繁琐。
也实在看不出任何要抛弃java，选用Scala的理由。
虽然函数式风格让程序代码显得很简洁，
但是我觉得越来越多的脚本语言让人们陷入一个误区：实现一个功能代码越少越好。
其实真的在开发的时候，我认为最易懂的代码是最好的。
哪怕有些实现不是太高效，有些算法不是太好，看起来有些罗唆。但是只要容易懂，无论将来维护还是交接，都是极大地降低成本。

11 楼 williamy 2008-04-16  

C4PO 写道

无聊的东西
一个介于Ruby和Java之间的怪胎
语法没有Ruby这样的纯动态类型语言简洁好看
静态检查又不如C++严格
毫无存在的必要

严重同意

1.java和JVM作为一种平台，继续稳定起来，同时推出groovy等动态的座位辅助
2.java继续添加closure等特性，丢掉老的特性，

我觉得java走第一条路比较好

10 楼 Eastsun 2008-04-15  

自言200801 写道

你说的没错，Scala声称它是纯面向对象的。

只是有时在一个函数体中，要是同时参杂着“a(b)”这样的格式，老得去看看a是数组名还是函数名，
所以看着不如a[b]那么明显。

呵呵,为什么不换个角度想呢.
Array使用下标取值不也是个函数调用过程吗,管他是什么,反正你只是传入一个int得到一个值,这样大统一不是蛮好嘛

9 楼 Eastsun 2008-04-15  

唔..
还有,关于运算符重载的事.
我在顶楼的文章中提过(不知你看到没有)
Scala中的运算符就是方法,只不过名字长的有点特殊而已
就是说  a +b
等价于  a.+(b)
(这个就可以解释为什么Scala中的方法调用要存在多钟形式了)
而且,所以,运算符重载在Scala中是天经地义的事---就是方法的覆写嘛

8 楼 Eastsun 2008-04-15  

To 自言200801

还有,那个关于数组访问使用圆括号的事.
我今天又看了一些资料,终于弄懂了Scala中为什么要"别出心裁"用圆括号来访问数组了.
它这样做是有道理的,在Scala中,一切皆是对象,而且都是平等的.
所以Scala中的Array中使用圆括号应该说来,比JAVA中更自然.
因为在Scala中,你只要实现了apply方法,你就可以像Array一样使用圆括号--事实上是调用了apply方法.
而且,如果你实现了update方法,你就可以想Array一样使用  array(index) =value
这样不是很好么?
你觉得呢.

PS:我讲的简化了,其实Scala中的函数也是对象---然后array(index)是不是就像个函数调用呢?对的,在Scala中基本可以说 对象 == 函数.

7 楼 Eastsun 2008-04-15  

自言200801 写道

今天又看了大半天的Scala文档(Scala By Example)，看着看着真的想“吐血”!
虽说Scala跟java整合的很好，当它的语法复杂度都快逼近C＋＋啦，
数组的[]、()这种使用风格对Java程序员来说很别扭，
类似println(df format now)这种用空格代替代句号跟括号的简化风格要是前面还有其他用逗号隔开的参数时也挺恶心的。
Scala就是一个大杂烩再参杂自己一些独特的语法。
名义上说比Java简洁，但要是搞Java的人你要他一开始就看Scala By Example也许也会像那篇文章的“愤青”一样。

那个,个人认为,很大程度上是Scala官网上给的文档侧重点不同,那些文档太学术化了.
如果是一个习惯了函数式编程的人去看估计会很爽(我没接触过FP,所以我也看的很郁闷).
我看JAVA的语言规范文档还能凑合着看,看Scala的语言规范文档看的云里雾里...
所以,对于像我习惯了JAVA这种命令式编程风格的人来说,得从其它途径去学习Scala.
这也是我翻译这篇文章的原因.在我后来看过一些资料后觉得,这篇文章的作者也不是很了解Scala,一些观点值得商酌.
但有一个很大的优点是,这系列文章是从JAVA的思维方式出发来看Scala,所以我看起来并不费力.

6 楼 williamy 2008-04-15  

scala現在在討論named parameters，作者說不會支持！
看看groovy的構造入口，多方便，對於java的也很容易理解
用腳趾頭思考就知道該怎麽使用

如果你認爲scala可以用java的庫，這個能吸引你的話
D語言能夠用C/C++的庫，應該更吸引人啊

特別註明D語言一出現，就一堆人用來創建新項目，1.0出來的時候，很多beta時候的都不兼容，2.0時候很多1.0的都不兼容，嘿嘿，可見，更新換代多厲害，

特別註明D語言作者是C++編譯器的一作者 是個有引響力的人

5 楼 williamy 2008-04-15  

嚴重贊同樓上的話
編程語言在整個編程開發過程中，它只是一個工具
工具而已，我相信這裡大部分都是使用工具的人
而不是那種設計工具的
所以我們才不管你的工具如何，我們要的是效果
管你叫C還是D

4 楼 Eastsun 2008-04-15  

看了你提到的那篇文章，感觉作者有点愤青-_-         我也很期待java7的闭包，只希望不要弄的像java5中的泛型一样鸡肋

3 楼 williamy 2008-04-15  

当大家都在努力考虑动态语言的时候，static的还有人继续，而且说的很完美，我应该说这是一种个性还是一种落后？
一个C++编译器的作者搞了个D语言，而且疯狂改写！吸收了很多风格，很多想法
等它开始稳定下来的时候，其他语言就没有什么生存的意义了（夸张了点）