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方法作為構造方法

一樣可以得到租察衡相同的結果