scala编译器

㈠ 高级编程:Scala编程语言简介

Scala编程语言近来抓住了很多开发者的眼球。如果你粗略浏览Scala的网站，你会觉得Scala是一种纯粹的面向对象编程语言，而又无缝地结合了命令式和函数式的编程风格。Christopher Diggins认为：
不太久之前编程语言还可以毫无疑义地归类成“命令式”或者“函数式”。Scala代表了一个新的语言品种，它抹平了这些人为划分的界限。
根据David Rupp在博客中的说法，Scala可能是下下一代友迹java.这么高的评价让人不禁想看看它到底是什么东西。
Scala有几项关键特性表明了它的面向对象的本质。例如，Scala中的每个值都是一个对象，包括基本数据类型（即布尔值、数字等）在内，连函数也是对象。另外，类可以被子类化，而且Scala还提供了基于mixin的组合（mixin-based composition）。
与只支持单继承的语言相比，Scala具有更广泛意义上的类重用。Scala允许定义新类的时候重用“一个类中新增的成员定义（即相较于其父类的差异之处）”。Scala称之为mixin类组合。
Scala还包含了若干函数式语言的关键概念，包括高阶函数（Higher-Order Function）、局部套用（Currying）、嵌套函数（Nested Function）、序列解读（Sequence Comprehensions）等等。
Scala是静态类型的，这就允许它提供泛型类、内部类、甚至多态方法（Polymorphic Method）。另外值得一提的是，Scala被特意设计成能够与Java和.NET互操作。Scala当前版本还不能在.NET上运行（虽然上一版可以），但按照计划将来可以在.NET上运行。
Scala可以与Java互操作。它用scalac这个编译器把源文件编译成Java的class文件（即在JVM上运行的字节码）。你可以从Scala中调用所有的Java类库，也同样可以从Java应用程序中调用Scala的代码。用David Rupp的话来说，
它也可以访问现存的数之不尽的Java类库，这让（潜在地）迁移到Scala更加容易。
这让Scala得以使用为Java1.4、5.0或者6.0编写的巨量的Java类库和框架，Scala会经常性地针对这几个版本的Java进行测试。Scala可能也可以在更早版本的Java上运行，但没有经过正式的测试。Scala以BSD许可发布，并且数年前就已经被认为相当稳定了。
说了这么多，我们还没有回答一个问题：“为什么我要使用Scala？”Scala的设计始终贯穿着一个理念：
创造一种更好地支持组件的语言。（《The Scala Programming Language》，Donna Malayeri）
也就是说软件应该由可重用的部件构造而成。Scala旨在提供一种编程语言，能够统一和一般化分别来自面向对象和函数式两种不同风格肢哗的关键概念。
藉着这个目标与设计，Scala得以提供一些出众的特性，包括：
* 面向对象风格
* 函数式风格
* 更高层的并发模型
Scala把Erlang风格的基于actor的并发带进了JVM.开发者现在可以利用Scala的actor模型在JVM上设计具伸缩性的并发应用程序，它会自动获得多核心处理器带来的优势，而不必依照复杂的Java线程模型来编写程序。
* 轻量级的函数语法
高阶
嵌套
局部套用（Currying）
匿名
* 与XML集成
可在Scala程序中直接书写XML
可将XML转换成Scala类
* 与Java无缝地互操作
Scala的风格和特性已经吸引了大量的开发者，比如Debasish Ghosh就觉得：
我已经把玩好饥并了Scala好一阵子，可以说我绝对享受这个语言的创新之处。
总而言之，Scala是一种函数式面向对象语言，它融汇了许多前所未有的特性，而同时又运行于JVM之上。随着开发者对Scala的兴趣日增，以及越来越多的工具支持，无疑Scala语言将成为你手上一件必不可少的工具。

㈡ Spark Shell因为Scala编译器原因不能正常启动怎么解决

Spark Shell由于Scala编译器原因不能正常启动

使用SBT安装完成Spark后，可以运行示例，但是尝试运行spark-shell就会报错：

D:\Scala\spark\bin\spark-shell.cmd
SLF4J: Class path contains multiple SLF4J bindings.
SLF4J:
Found binding in
[jar:file:/D:/Scala/spark/assembly/target/scala-2.10/spark-assembly-0.9.0-incubating-hadoop1.0.4.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: Found binding in
[jar:file:/D:/Scala/spark/tools/target/scala-2.10/spark-tools-assembly-0.9.0-incubating.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: See http://www.slf4j.org/codes.html#multiple_bindings for an explanation.
SLF4J: Actual binding is of type [org.slf4j.impl.Log4jLoggerFactory]
14/04/03 20:40:43 INFO HttpServer: Using Spark's default log4j profile: org/apache/spark/log4j-defaults.properties
14/04/03 20:40:43 INFO HttpServer: Starting HTTP Server

Failed to initialize compiler: object scala.runtime in compiler mirror not found.
** Note that as of 2.8 scala does not assume use of the java classpath.
** For the old behavior pass -usejavacp to scala, or if using a Settings
** object programatically, settings.usejavacp.value = true.
14/04/03
20:40:44 WARN SparkILoop$SparkILoopInterpreter: Warning: compiler
accessed before init set up.  Assuming no postInit code.

Failed to initialize compiler: object scala.runtime in compiler mirror not found.
** Note that as of 2.8 scala does not assume use of the java classpath.
** For the old behavior pass -usejavacp to scala, or if using a Settings
** object programatically, settings.usejavacp.value = true.
Failed to initialize compiler: object scala.runtime in compiler mirror not found.
        at scala.Predef$.assert(Predef.scala:179)
       
at
org.apache.spark.repl.SparkIMain.initializeSynchronous(SparkIMain.scala:197)
       
at
org.apache.spark.repl.SparkILoop$$anonfun$process$1.apply$mcZ$sp(SparkILoop.scala:919)
       
at
org.apache.spark.repl.SparkILoop$$anonfun$process$1.apply(SparkILoop.scala:876)
       
at
org.apache.spark.repl.SparkILoop$$anonfun$process$1.apply(SparkILoop.scala:876)
       
at
scala.tools.nsc.util.ScalaClassLoader$.savingContextLoader(ScalaClassLoader.scala:135)
       
at org.apache.spark.repl.SparkILoop.process(SparkILoop.scala:876)
       
at org.apache.spark.repl.SparkILoop.process(SparkILoop.scala:968)
        at org.apache.spark.repl.Main$.main(Main.scala:31)
        at org.apache.spark.repl.Main.main(Main.scala)

Google
之还是不求解。只是在SBT的网站上看到Q&A里面有个问题提到了：http://www.scala-sbt.org/release
/docs/faq#how-do-i-use-the-scala-interpreter-in-my-code。这里说代码中怎么修改设置。显然不
适合我。

继续求解。注意到错误提示是在2.8以后才有的，原因是有一个关于编译器解释权Classpath的提议被接受了：Default compiler/interpreter classpath in a managed environment。

继续在Google中找，有一篇论文吸引了我的注意：Object Scala Found。里面终于找到一个办法：

“

However, a working command can be recovered, like so:
$ jrunscript -Djava.class.path=scala-library.jar -Dscala.usejavacp=true -classpath scala-compiler.jar -l scala

”

于是修改一下\bin\spark-class2.cmd:

rem Set JAVA_OPTS to be able to load native libraries and to set heap size
set
JAVA_OPTS=%OUR_JAVA_OPTS% -Djava.library.path=%SPARK_LIBRARY_PATH%
-Dscala.usejavacp=true -Xms%SPARK_MEM% -Xmx%SPARK_MEM%
rem Attention: when changing the way the JAVA_OPTS are assembled, the change must be reflected in ExecutorRunner.scala!

标红的部分即是心添加的一个参数。再次运行\bin\spark-shell.cmd:

D:>D:\Scala\spark\bin\spark-shell.cmd
SLF4J: Class path contains multiple SLF4J bindings.
SLF4J:
Found binding in
[jar:file:/D:/Scala/spark/assembly/target/scala-2.10/spark-assembly-0.9.0-incubating-hadoop1.0.4.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: Found binding in
[jar:file:/D:/Scala/spark/tools/target/scala-2.10/spark-tools-assembly-0.9.0-incubating.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: See http://www.slf4j.org/codes.html#multiple_bindings for an explanation.
SLF4J: Actual binding is of type [org.slf4j.impl.Log4jLoggerFactory]
14/04/03 22:18:41 INFO HttpServer: Using Spark's default log4j profile: org/apache/spark/log4j-defaults.properties
14/04/03 22:18:41 INFO HttpServer: Starting HTTP Server
Welcome to
     

____             
__
     / __/__  ___ _____/ /__
    _\ \/ _ \/ _ `/ __/  '_/
   /___/ .__/\_,_/_/ /_/\_\   version 0.9.0
      /_/

Using Scala version 2.10.3 (Java HotSpot(TM) Client VM, Java 1.6.0_10)
Type in expressions to have them evaluated.
Type :help for more information.
14/04/03 22:19:12 INFO Slf4jLogger: Slf4jLogger started
14/04/03 22:19:13 INFO Remoting: Starting remoting
14/04/03 22:19:16 INFO Remoting: Remoting started; listening on addresses :[akka.tcp://spark@Choco-PC:5960]
14/04/03 22:19:16 INFO Remoting: Remoting now listens on addresses: [akka.tcp://spark@Choco-PC:5960]
14/04/03 22:19:16 INFO SparkEnv: Registering BlockManagerMaster
14/04/03
22:19:17 INFO DiskBlockManager: Created local directory at
C:\Users\Choco\AppData\Local\Temp\spark-local-20140403221917-7172
14/04/03 22:19:17 INFO MemoryStore: MemoryStore started with capacity 304.8 MB.
14/04/03 22:19:18 INFO ConnectionManager: Bound socket to port 5963 with id = ConnectionManagerId(Choco-PC,5963)
14/04/03 22:19:18 INFO BlockManagerMaster: Trying to register BlockManager
14/04/03 22:19:18 INFO BlockManagerMasterActor$BlockManagerInfo: Registering block manager Choco-PC:5963 with 304.8 MB RAM
14/04/03 22:19:18 INFO BlockManagerMaster: Registered BlockManager
14/04/03 22:19:18 INFO HttpServer: Starting HTTP Server
14/04/03 22:19:18 INFO HttpBroadcast: Broadcast server started at http://192.168.1.100:5964
14/04/03 22:19:18 INFO SparkEnv: Registering MapOutputTracker
14/04/03
22:19:18 INFO HttpFileServer: HTTP File server directory is
C:\Users\Choco\AppData\Local\Temp\spark-e122cfe9-2d62-4a47-920c-96b54e4658f6
14/04/03 22:19:18 INFO HttpServer: Starting HTTP Server
14/04/03 22:19:22 INFO SparkUI: Started Spark Web UI at http://Choco-PC:4040
14/04/03 22:19:22 INFO Executor: Using REPL class URI: http://192.168.1.100:5947
Created spark context..
Spark context available as sc.

scala> :quit
Stopping spark context.
14/04/03 23:05:21 INFO MapOutputTrackerMasterActor: MapOutputTrackerActor stopped!
14/04/03 23:05:21 INFO ConnectionManager: Selector thread was interrupted!
14/04/03 23:05:21 INFO ConnectionManager: ConnectionManager stopped
14/04/03 23:05:21 INFO MemoryStore: MemoryStore cleared
14/04/03 23:05:21 INFO BlockManager: BlockManager stopped
14/04/03 23:05:21 INFO BlockManagerMasterActor: Stopping BlockManagerMaster
14/04/03 23:05:21 INFO BlockManagerMaster: BlockManagerMaster stopped
14/04/03 23:05:21 INFO SparkContext: Successfully stopped SparkContext
14/04/03 23:05:21 INFO RemoteActorRefProvider$RemotingTerminator: Shutting down remote daemon.
14/04/03
23:05:21 INFO RemoteActorRefProvider$RemotingTerminator: Remote daemon
shut down; proceeding with flushing remote transports.

Good。浏览器打开http://Choco-PC:4040，就可以看到Spark的状态、环境、执行者等信息了。

这个Fix可能只是适用与我的情况。如果还有问题可以再找找相关的资料。

期间还碰到不能找到文件的错误。最后发现是JAVA_HOME设置没有对。如果你碰到问题了，可以打开脚本的回显，然后找找原因。

㈢ Scala语言的主要应用领域与作用

Scala的特性
1.面向对象特性
Scala是一种纯面向对象的语言，每一个值都是对象。对象的数据类型以及行为由类和特征（Trait）描述。类抽象机制的扩展有两种途径。一种途径是子类继承，另一种途径是灵活的混入（Mixin）机制。这两种途径能避免多重继承的种种问题。

2.函数式编程
Scala也是一种函数式语言，其函数也能当成值来使用。Scala提供了轻量级的语法用以定义匿名函数，支持高阶函数，允许嵌套多层函数，并支持柯里化。Scala的CaseClass及其内置的模式匹配相当于函数式编程语言中常用的代数类型（AlgebraicType）。

更进一步，程序员可以利用Scala的模式匹配，编写类似正则表达式的代码处理XML数据。在这些情形中，顺序容器的推导式（comprehension）功能对编写公式化查询非常有用。

由于JVM不支持尾部递归，Scala也不能完全支持尾部递归优化。不过，在简单的情况下，Scala编译器可以把尾部递归优化成循环。

4.静态类型
Scala是具备类型系统，通过编译时的检查，保证代码的安全性和一致性。类型系统具体支持以下特性：

泛型类，型变注释（VarianceAnnotation），类型继承结构的上限和下限，把类别和抽象类型作为对象成员，复合类型，引用自己时显式指定类型，视图，多态方法。

5.扩展性
Scala的设计承认一个事实，即在实践中，某个领域特定的应用程序开发往往需要特定于该领域的语言扩展。Scala提供了许多独特的语言机制，可以以库的形式轻易无缝添加新的语言结构：

任何方法可用作前缀或后缀操作符，可以根据预期类则橘型自动构造闭包。联合使用以上两个特性，使你可以基毁定义新的语句而无须扩展语法也无须使用宏之类的元编程特性。

5.使用Scala的框架
Lift是一个开源的Web应用框架，旨在提供类似RubyonRails的东西。因为Lift使用了Scala，所以Lift应用程序可以使用所有的Java库和Web容器。

scala语言主要应用领域
cala运行于JVM之上，并且它可以访问任何的java类库并且与java框架进行互操作，scala也大量重用了java类型和类库。

大数据的开发语言是Scala的原因：

1：大数据的本身是计算数据，而Scala即有面向对象组织项目工程的能力，又有计算数据的功能。

2：现在大数据事实上的计算标准框架Spark，它是用Scala开发的，因为计算数据，Scala它是函数式编程，它实现算法非常简洁优雅。

例：kafka，它是一个消息中间件，如果外部数据要流进大数据中心，我们一般都要用kafka作适配器，那如果大数据中心的数据流到外部，也是用kafka（如Spark计算的数据要交给HBASE或MySql，期间我们都会用kafka），很多的大数据组件都是用的Scala编写的，所以，如果你想成为一个较高级的孙锋团大数据开发高手，你一定要掌握Scala。

㈣ 为什么scala 编译时异常可以不用捕获

不用捕获是因为Scala 编译器不做这方面检查啊，自然你不捕获不抛出也能过编译。至于为什么Scala 编译器不检查异常，是因为语言设计者们认为异常不是好的错误处理实践。理由如下：
1，异常会打断执行流，因此不是类型安全的
2，异常不利于类型推断
3，从实践来看，大部分程序员并不会认真处理异常，不是catch下打个log就是继续往外throw了事，结果就是又臭又长的throw
4, 丑，这是原罪。
Scala 鼓励使用类型来表示错误信息，例如Option与Future ，Either, 选择与未来（:-D），这样控制流里你可以带着错误信息一直往下走，直到一个能优雅处理错误的位置。

㈤ Scala 是一门怎样的语言，具有哪些优势

曾经有人问Java的创始人高斯林这样一个问题，“除了Java语言以外，您现在还使用JVM平台上的哪种编程语言?”他毫不犹豫的说是Scala。

Scala到底是什么?在目前众多的JVM语言当中，Scala无疑是最引人注意的语言之一。Scala是一个静态语言，更适合大型工程项目，Scala直接编译成Java字节码，性能接近Java。Scala是一个多范式的语言，你可以混合使用函数式和面向对象编程，混合使用可变类和不变类，混合使用Actor和传统的Java并发库。
短短一个月的时间，Scala于本月冲进了TIOBE的前五十名。一个 Twitter 的开发人员说过，Scala 将会成为现代 Web2.0 的发起语言。LinkedIn 也用这种语言。同样许多其他大的公司如 Sony Picture, EDF, SAP 也开始使用这种语言。为什么Scala发展这么迅猛，可以获得如此热烈的社区支持。
曾冠东还表示，Scala不是Java的杀手，它无法取代Java的地位，也突破不了JVM的限制、Java实现不了的功能它也实现不了。我们可以将Scala形象的理解成大量语法糖的Java。
Scala 开发团队发布了最新的2.9.2稳定版本，Scala 语言的特性有许多，例如高阶函数和对象、抽象类型绑定，actor 使得函数在 Scala 中能是一个子类成为可能，Scala 中的设计模式使得面向对象和函数编程无缝结合。Akka 是一个用 Scala 编写的库，用于简化编写容错的、高可伸缩性的 Java 和 Scala 的 Actor 模型应用。它已经成功运用在电信行业。Spark 是一种可扩展的数据分析平台，它整合了内存计算的基元，因此，相对于 Hadoop 的集群存储方法，它在性能方面更具优势。Spark 是在 Scala 语言中实现的，并且利用了该语言，为数据处理提供了独一无二的环境。Scala 编译器可以生成字节码，直接运行在使用JVM上。该语言(它实际上代表了可扩展语言)被定义为可直接集成到语言中的简单扩展。
Scala作为一门静态语言，它的主要特性有哪些?
· Scala是面向对象的
Scala是一个纯面向对象语言，在某种意义上来讲所有数值都是对象。对象的类型和行为是由class和trait来描述的。Class的抽象可由子类化和一种灵活的基于mixin的组合机制(它可作为多重继承的简单替代方案)来扩展。
· Scala是函数式的
Scala还是一个函数式语言，在某种意义上来讲所有函数都是数值。Scala为定义匿名函数提供了一种轻量级的语法，它支持高阶(higher-order)函数、允许函数嵌套、支持局部套用(currying)。Scala的case类及其内置支持的模式匹配模型代数类型在许多函数式编程语言中都被使用。
· Scala是静态类型的
Scala配备了一套富有表现力的类型系统，该抽象概念以一种安全的和一致的方式被使用。
· Scala是可扩展的
Scala的设计承认了实践事实，领域特定应用开发通常需要领域特定语言扩展。Scala提供了一个独特的语言组合机制，这可以更加容易地以类库的形式增加新的语言结构：
任何方式可以被用作中缀(infix)或后缀(postfix)操作符闭包按照所期望的类型(目标类型)自动地被构造
两者结合使用可方便地定义新语句，无需扩展语法，也无需使用类似宏的元编程工具。
· Scala可与Java和.NET进行互操作
Scala设计时就考虑了与流行编程环境良好交互，如Java 2运行时环境(JRE)和 .NET框架(CLR)。特别是与主流面向对象语言，如Java和C#尽量无缝交互。Scala有像Java和C#一样的编译模型(独立编译，动态装载类)，允许访问成千上万的高质量类库。
在并发性方面，与 Scala 在 .NET 领域中的姐妹语言 F# 相似，Scala 是针对 “并发性问题” 的解决方案之一，让开发人员能够更加轻松地专注于问题的实质，而不用考虑并发编程的低级细节。Actor 编程模式让高度并行应用程序的开发更加简单。Scala把Erlang风格的基于actor的并发带进了JVM。我们可以利用Scala的actor模型在JVM上设计具伸缩性的并发应用程序，以自动获得多核心处理器带来的优势，而不必依照复杂的Java线程模型来编写程序。Scala 为并发性提供了两种级别的支持，这与其他与 Java 相关的主题极为类似：
首先，对底层库的完全访问(比如说 java.util.concurrent)以及对 “传统” Java 并发性语义的支持(比如说监控程序和wait()/notifyAll())。其次，这些基本机制上面有一个抽象层
Scala 提供了在稳定的高性能平台(Java 虚拟机)上生成的能力同时也是一门敏捷性语言。这一类型的语言也有其他的选择，例如 Jython, JRuby, Groovy 和 Clojure, 但是这些都是运行在 JVM 上的动态类型语言。Open Class 的效果让大家会觉得Scala是动态语言，但它是选择隐式转换来实现的，这也正好证明了Scala是静态语言。隐式转换(Implicit conversion)使 Scala 具有类型安全性，正如扩展方法(extension method)之于 C#，开放类(open class)之于 ruby。即：向未曾定义的类型添加方法(如字符串、列表、整数)。这是使得 Scala 符合 DSL(特定领域语言)模型的特性之一。
Scala结合了面向对象和函数编程的优势，函数编程的一个好处就是你能够像运用一个数据那样运用函数，可以用来定义真正高层级的库，或者去定义新的领域特殊语言(DSL)。

在谈及Java与Scala的对比时，曾冠东表示，Scala能调用绝大部分的Java，而Java调用Scala独有的东西会比较难。Java 拥有非常强的概念规范，因此任何一个 Java 程序之间具有非常多的相似之处，并且这样能够方便的进行程序员交替。但是 Scala 并没有这样的统一性，因为这是一门很有表现力的语言。现场曾冠东为我们演示了实际案例，如下图所示：

正所谓，金无足赤，人无完人。Scala对二进制不兼容，语法也越来越复杂，不能突破Bytecode的限制、编译速度有所缓慢。当它被广泛用于单元测试、开发工具、Socket开发、以及面对多核挑战的并发应用。总而言之，Scala是一种函数式面向对象语言，它融汇了许多前所未有的特性，而同时又运行于JVM之上。正如JRuby 创建者之一Charles Nutter 所宣称的那样Scala就是 Java 王位的合法继承人。随着开发者对Scala的兴趣日增，以及越来越多的工具支持，无疑Scala语言将成为广大软件工程师手上一件必不可少的工具。更多精彩内容，请关注专题：http://www.it168.com/remen/qcon/

㈥ Scala编程语言简介

Scala编程语言近来抓住了很多开发者的眼球 如果你粗略浏览Scala的网站 你会觉得Scala是一种纯粹的面向对象编程语言 而又无缝地结合了命令式和函数式的编程风格 Christopher Diggins认为

不太久之前编程语言还可以毫无疑义地归类成 命令式 或者 函数式 Scala代表了一个新的语言品种 它抹平了这些人为划分的界限

根据David Rupp在博客中的说法 Scala可能是下下一代Java 这么高的评价让人不禁想看看它到底是什么东西

Scala有几项关键特性表明了它的面向对象的本质 例如 Scala中的每个值都是一个对象 包括基本数据类型（即布尔值 数字等）在内 连函数也是对象 另外 类可以被子类化 而且Scala还提供了基于mixin的乎迟让组合（mixin based position）

与只支持单继承的语言相比 Scala具有更广泛意义上的类重用 Scala允许定义新类的时候重用 一个类中新增的成员定义（即相较于其父类的差异之处） Scala称之为mixin类组合

Scala还包含了若干函数式语言的关键概念 包括高阶函数（Higher Order Function） 局部套用（Currying） 嵌套函数（Nested Function） 序列解读（Sequence Comprehensions）等等

Scala是静态类型的 这就允许它提供泛型类 内部类 甚至多态方法（Polymorphic Method） 另外值得一提的是 Scala被特意设计成能够与Java和 NET互操作 Scala当前版本还不能在 NET上运行（虽然上一版可以） 但按照计划将来可以在 NET上运行

Scala可以与Java互操作 它用scalac这个编译器把源文件编译成Java的class文件（即在JVM上运行的字节码） 你可以从Scala中调用所有的Java类库 也同样可以从Java应用程序中调用Scala的代码 用David Rupp的话来说

它也可以访问现存的数之不尽的Java类库 这让（潜在地）迁移到Scala更加容易

这让Scala得以使用为Java 或者 编写的巨量的Java类库和框架 Scala会经常性地针对这几个版本的Java进行测试 Scala可能也可以在更早版本的Java上运行 但没有经过正式的测试 Scala以BSD许可发布 并且数年前就已经被认为相当稳定了

说了这么多 我们还没有回答一个问题 为什么我要使用Scala？ Scala的设计始终贯穿着一个理念

创造一种更好地支持组件的语言 （《The Scala Programming Language》 Donna Malayeri）

也就是说软件应该由可重用的部件构造而成 Scala旨在提供一种编程语言 能够统一和一般化分别来自面向对象和函数式两种不同风格的关键概念岁局

借着这个目标与设计 Scala得以提供一些出众的特性 包括

* 面旦丛向对象风格

* 函数式风格

* 更高层的并发模型

Scala把Erlang风格的基于actor的并发带进了JVM 开发者现在可以利用Scala的actor模型在JVM上设计具伸缩性的并发应用程序 它会自动获得多核心处理器带来的优势 而不必依照复杂的Java线程模型来编写程序

* 轻量级的函数语法

o 高阶

o 嵌套

o 局部套用（Currying）

o 匿名

* 与XML集成

o 可在Scala程序中直接书写XML

o 可将XML转换成Scala类

* 与Java无缝地互操作

Scala的风格和特性已经吸引了大量的开发者 比如Debasish Ghosh就觉得

我已经把玩了Scala好一阵子 可以说我绝对享受这个语言的创新之处

lishixin/Article/program/Java/hx/201311/26873

㈦ Scala型变

“型变(Variance)”是一个令人费解的概念，但它却是理解类型系统的重要基源枣石。本文首先讨论型变的基本概念，深入理解型变的基本形态。然后以 List, Option 为例讲解型变在 Scala 中的应用；最后通过 ScalaHamcrest 的实战，加深对此概念的理解和运用。

其中， Mutable 常常意味着 Nonvariant ，但是 Noncovariant 与 Mutable 分别表示两个不同的范畴。

“型变(Variance)”拥有三种基本形态：协变(Covariant), 逆变(Contravariant), 不变(Nonconviant)，可以形式化地描述为：

Scala 的类型参数使用 + 标识“协变”， - 标识“逆变”，而不带任何标识的表示“不变”(Nonvariable)。

事实上，判定一个类型是否拥有型变能力的准则非常简单。

Supplier 是一个生成者，它生产 T 类型的实例。

Consumer 是一个消费者，它消费 T 类型的实例。

Function1 是一个一元函数，它既是一个生产者，又是一个消费者，但它是不可变的(Immutable)。其中，入参类型为 -T ，返回值类型为 +R ；对于参数类型，函数是逆变的，而对于返回值类型，函数则是协变的。

与 Function1 不同，虽然数组类型既是一个生产者，又是一个消费者。但是，它是一个可变的(Mutable)类型，因此它是不变的(Nonvariant)。

综上述，可以得到 2 个简单的结论。

幸运的是， Scala 编译器能够完弯梁成这个约束的检查。例如，

编译器将检测到编译错误。

例如，给定两个函数 F1, F2 。

则 F1 <: F2 成立。

Option 是一个递归的数据结构，它要么是 Some ，要么是 None 。其中， None 表示为空，是递归结束的标识。

使用 Scala ，可以很直观地完成 Option 的递归定义。

因为 Option 是不可变的(Immutable)，因此 Option 应该设计为协变的，即 Option[+A] 。也就是说，对于任意的类型 A ， Option[Nothing] <: Option[A] ，即 None <: Option[A] 都成立。

与 Option 类似， List 也是一个递归的数据结构，它由头部和尾部组成。其中， Nil 表示为空，是递归结束的标识。

使用 Scala ，可以很直观地完成 List 的递归定义。

因为 List 是不可变的(Immutable)，因此 List 应该设计为协变的，即 List[+A] 。也就是说，对于任意的类型 A ， List[Nothing] <: List[A] ，即 Nil <: List[A] 都成立。

可以在 List 中定义了 cons 算子，用于在 List 头部追求元素。

此时，编译器将报告协变类型 A 出现在逆变的位置上的错误。因此，在遵循“里氏替换”的基本原则，使用“下界(Lower Bound)”对 A 进行界定，转变为“不变的(Nonvariable)”的类型参数 A1 。

至此，又可以得到一个重要的结论。

List 的 cons 算子就是通过使用“下界”界定协变类型参数 A ，将其转变为不变的(Nonvariable)类型参数 A1 的。而对于“上界”，通过实现 ScalaHamcrest 的基本功能进行讲述，并完成整个型变理论知识的回顾和应用。

对于任意的类型 A ， A => Boolean 常常称为“谓词”；如果该谓词用于匹配类型 A 的某个值，也埋裂运常常称该谓词为“匹配器”。

ScalaHamcrest 首先定义一个 Matcher ，并添加了 &&， ||， ! 的基本操作，用于模拟谓词的基本功能。

对于函数 A => Boolean ，类型参数 A 是逆变的。因此，为了得到支持型变能力的 Matcher ，应该将类型参数 A 声明为逆变。

但是，此时 &&, || 将报告逆变类型 A 出现在协变的位置上。为此，可以使用“上界”对 A 进行界定，转变为不变的(Nonvariant)类型 A1 。

基于 Matcher ，可以定义特定的原子匹配器。例如：

也可以定义 EqualTo 的原子匹配器，用于比较对象间的相等性。

与 EqualTo 类似，可以定义原子匹配器 Same ，用于比较对象间的一致性。

其中， A <: AnyRef类型 对 A 进行界定，排除 AnyVal 的子类误操作 Same 。类似于类型上界，也可以使用其他的类型界定形式；例如，可以定义 InstanceOf ，对类型 A 进行上下文界定，用于匹配某个实例的类型。

有时候，基于既有的原子可以很方便地构造出新的原子。

也可以将各个原子或者组合器进行组装，形成威力更为强大的组合器。

特殊地，基于 AnyOf/AllOf ，可以构造很多特定的匹配器。

修饰也是一种特殊的组合行为，用于完成既有功能的增强和补充。

其中， Not, Is 是两个普遍的修饰器，可以修饰任意的匹配器；也可以定义针对特定类型的修饰器。例如，可以定义针对字符串操作的原子匹配器和修饰匹配器。

如果要忽略大小写，则可以通过定义 IgnoringCase ，修饰既有的字符串的原子匹配器。

有时候，可以通过定义语法糖，提升用户感受。例如，可以使用 Not 替换 Not(EqualTo) ， Is 替代 Is(EqualTo) ，不仅减轻用户的负担，而且还能提高表达力。

至此，还不知道 ScalaHamcrest 如何使用呢？可以定义一个实用方法 assertThat 。

其中， assert 定义于 Predef 之中。例如存在如下一个测试用例。

也可以使用 && 直接连接多个匹配器形成调用链，替代 AllOf 匹配器。

此处为了演示“型变”的作用， ScalaHamcrest 采用了 OO 与 FP 相结合的设计手法，在下一章讲解“Scala函数论”时， ScalaHamcrest 将采用纯函数式的设计手法实现，敬请关注。

㈧ 编程语言scala有哪些特点

Scala有交互式命令行(REPL), 可以在上面快速的试各种语法和代码。这对学习新特性，或者实验新想法非常有用。(第1章)
一致性: 尽管Scala融合了静态类型系统、面向对象、函数式编程等语言特性，但却很少能看出融合的痕迹。Scala是我见到融合最多语言特性而又不显得杂乱的编程语言之一。
类型安全：Scala创始人是教授，他先带领创建了Java 5编译器，而后觉得Java有太多羁绊而发明了Scala。 Scala编译器和类型系统非常强大，它的目标是尽量把软件错误消灭在编写过程中。 Scala类型系统是图灵完备的，甚至可以在编译期间解决问题。
面向对象: Scala是面向对象的编程语言，所有的变量和方法都封装在对象中，可以把信息封装起来供外部使用。(第2章)
函数式编程：Scala同时又是函数式编程语言，函数可以独立存在，可以定义一个函数作为另一个函数的返回值，也可以接受函数作为函数的参数。这给组合函数带来了很大的便利。如何把面向对象编程形容成搭积木的话，函数式编程就像拼线条，更灵活和更有创意。(第3章)
异步编程: 由于函数式编程提倡变量不可变，使异步编程变得非常容易。同时Scala提供的Future(第5章)， 和akka类库(第9-11章)，使得异步编程变得非常容易。
基于JVM: Scala会被编译成为jvm bytecode,所以Scala能无缝集成已有的Java类库。你可以非常自然的使用已经存在的非常庞大且稳定的Java类库，比如小巧好用的apache.common.*, 或者Java上的各种工具类库。

因为如此众多特性，用Scala可以优雅地编写简洁的代码，同时又能减少很多低级错误；能快速进行开发，又能保证系统性能、团队协作和长期维护。

㈨ 详解 Scala 模式匹配

本篇博客中我们将采用类似的方法，并熟悉Scala编程语言的另一个重要特性— 模式匹配 。同样我们将通过编写一些简短的代码片段，一系列小步骤来逐步深入。

case 类的许多其他有用特性（例如结构化 equals、hashCode、 和 toString）中，Scala 编译器支持以下代码

请注意这里的一个很好的对称性：构造时me 在左侧，带有两个字符串参数的 FullName(...) 在赋值的右侧，解构时正好相反。

当谈到 Scala 模式匹配时，首先想到的是困慎 match 语句（它类似于许多其他编程语言中的 switch / case，但是更强大）。可以在 Scala 中的很多地方可以使用模式匹配：你可以在定义 lambda 函数时使用它，也可以在 for-comprehension 生成器的左侧，甚至在上面例子中的赋值语句中。为简单起见，在本文的其余部分，我们将主要在赋值语句中使用模式匹配。

现在我们已经定义了case类以及一些使用它的代码，接着尝试了解 Scala case类的特别之处以及如何使用相关代码。有时理解某事物如何工作的一个非常好的方法是破型纯坏它，然后尝试使其再次工作！先将 FullName 类定义的 case 关键字排除

如果尝试上述代码，会发现代码（value me 的构建和它的解构）编译报错。为了修复它，我们需要在事情开始崩溃之前手动实现 Scala 编译器之前提供给我们的功能，我们为 FullName 类添加一个伴随对象

Scala 中的伴生对象是一个单例，与它的伴生类同名且在同一个文件中。而且伴随对象和它的类可以访问彼此的私有成员。伴生对象是放置类的静态成员的地方（与 Java 不同，Scala 没有 static 修饰符），这提供了更清晰的静态/实例成员分离。

注意：我们必须稍微更改 FullName 类定义，以使 FullName.unapply 编译成功

如果不进行修改，first 和 last 只会作为构造函数的参数，无法通过 unapply 访问它们。在 first 和 last 之前添加 val 会将它们同时转换为构造函数参数和实例字段（默认为 public）。在我们删除 case 关键字之前Scala 编译器会自动为我们生成此功能以及伴随对象。

现在手动添加所有这些代码可以修复编译问题，继续让我们深入了解刚刚实现的两个方法的细节

apply 是 Scala 中的一个特殊方法名称，按照约定可以在代码中省略，所以 FullName(...) 等价于 FullName.apply(...) ，我们正在使用它来构造 FullName 的新实例，而无需 new 关键字。

unapply 正好相反——它解构了一个 FullName 的实例，并且是模式匹配的基础，接下来我们将重点介绍这种方法，在这种情况下，它将 FullName 解构为两个字符串值，并将它们包装在 Some 中，这意味着它可以匹配 FullName 的任何实例（稍后我们将探讨部分匹配partial matching）。

再次注意这两个方法的对称性： apply 将两个字符串作为参数，并返回一个 FullName 的实例。而 unapply 则恰好相反。

现在我们对什么是 unapply 以及它如何用于解构/模式匹配有了一个非常基本的了解。在大多数情况下，它已经由 Scala 处理—— unapply 的实现不仅为我们编写的所有case类提供，而且为几乎所有 Scala 标准库中的所有内容提供，包括集合（如果适用），事实上汪租敬实现自己的 unapply 并不常见，除非你是某个有趣库的开发者，然而我们可以作弊—在Java中unapply 肯定不存在，让我们从 java.time 中获取一些类，并在它们上添加对 Scala 模式匹配的支持

能够将 Date 分解为年、月和日，将 Time 分解为小时、分钟和秒，这很自然。此外DateTime — 转换为日期和时间，根据我们已有的知识，这非常简单。但是我们不能使用名称 LocalDate、LocalDateTime 和 LocalTime 来创建合适的伴生对象，因为伴生对象需要与对应的类放在相同的文件，但由于这些类来自 Java 标准库，因此不可能。为了避免名称冲突，我们简单地将实现对象的名称中省略 Local

接着使用它们：

LocalDate 和 LocalTime 都按照预期被解构为 3 个 Int 值。如果我们只需要一些解构的值而不需要其他值，可以使用下划线代替那些不需要的值

一个更有趣的例子是 LocalDateTime 的嵌套解构

这为我们提供了 6 个 Int 值（日期部分为 3，时间部分为 3）。

模式匹配的另一个非常有用的特性是整个值的赋值，这可以在解构之外完成。对于我们的 DateTime 示例，它可能如下所示

除了 6 个 Int 值，还得到一个 LocalDate 值，一个是 LocalTime 值，最后是 LocalDateTime 的整个值（以 dt 为单位）。

在上面的所有示例中，我们都解构为固定数量的值——（年、月、日）、或（时、分、秒）或（日期、时间）。在某些情况下我们需要处理一系列值，而不是某些固定数量的值，可以尝试通过将 LocalDateTime 解构为一系列 Int

unapplySeq 是 unapply 的变体，它解构为一系列值而不是固定大小的元组。在这个例子中，序列的长度总是 6，但可以省略它的尾部，因为不需要它

_* 是 Scala varargs 的语法

到现在为止， unapply / unapplySeq 总是返回 Some。为此 unapply 将返回 Some 以防该值符合某些条件，而 None 则不符合。我们已经在处理 LocalTime 的值，将它们匹配到 AM 或 PM 时间将是一个自然的例子

其中 case _ => 是默认情况，如果没有其他匹配项，则会使用此进行匹配，此外我们刚刚介绍了另外两个用于部分匹配的功能

•守卫（guards），例如case Time(h, m, s) if h < 12•常量匹配，例如case Time(12, m, s)

现在已经看到 Scala 模式匹配的强大功能！

我们自己实现一个可以很好地格式化当前时间的时钟，通过使用模式匹配和 AM / PM 提取器（加上一些看起来像表情符号流的老派 Java 字符串格式）

我们已经 探索 了 Scala 模式匹配的大部分特性。可以在这里 [1] 找到这篇博文的所有源代码，为了更好地理解可以在 IntelliJ IDEA中运行这些代码，最后如果 Scala 代码中有一些复杂的、嵌套的 ifs 和 elses，请尝试使用模式匹配来更好地重构它。

[1] 这里: https://gist.github.com/linasm/

㈩ Scala中的特殊概念，伴生对象

在Scale中，如果有一个class，还有一个与class同名的弊做object，那么就称这个object是class的 伴生对象 ，class是object的 伴生类。

创建一个Person object和Person class

执行

apply是object中非常重要的一个特殊方法，通常在伴生对象中实现apply方法，并在其中实现构造伴生类对象的功能
在创建对象的时候，就不需要使用new Class的方式，而是使用Class()的方式，隐式调用伴生对象的apply方法，这没卜样会让对象创建更加简洁

例如：Array的伴生对象的apply方法就实现了接收可变数量的参数，以及会创建一个Array对象
val a = Array(1, 2, 3, 4, 5)

下面我们来自己定义一个伴生类和伴生对象

执行

这两种方式肯定Person(“zhang”)这种方式使用起来更加方便简洁

另外我们可以使用case class...
scala编译器会自动为case class生成apply方法作为构造方法

一样可以得到租察衡相同的结果