Scala總結

抽象類和抽象成員

與java相似，scala中abstract宣告的類是抽象類，抽象類不可以被例項化。

在scala中，抽象類和特質中的方法、欄位和型別都可以是抽象的。示例如下：

trait MyAbstract {

type T // 抽象型別

def transform(x: T): T // 抽象方法

val initial: T // 抽象val

var current: T // 抽象var

}

抽象方法：抽象方法不需要（也不允許）有abstract修飾符，一個方法只要是沒有實現（沒有等號或方法體），它就是抽象的。

抽象型別：scala中的型別成員也可以是抽象的。抽象型別並不是說某個類或特質是抽象的

(特質本身就是抽象的)，抽象型別永遠都是某個類或特質的成員。

抽象欄位：沒有初始化的val或var成員是抽象的，此時你需要指定其型別。抽象欄位有時會扮演類似於超類的引數這樣的角色，這對於特質來說尤其重要，因為特質缺少能夠用來傳遞引數的構造器。因此引數化特質的方式就是通過在子類中實現抽象欄位完成。如對於以下特質：

trait MyAbstract {

val test: Int

println(test)

def show() {

println(test)

}

}

你可以使用如下匿名類語法建立繼承自該特質的匿名類的例項，如下：

new MyAbstract {

val test = 1

}.show()

你可以通過以上方式引數化特質，但是你會發現這和“new 類名(引數列表)”引數化一個類例項還是有區別的，因為你看到了對於test變數的兩次println(第一次在特質主體中，第二次是由於呼叫了方法show)，輸出了兩個不同的值(第一次是0，第二次是1)。這主要是由於超類會在子類之前進行初始化，而超類抽象成員在子類中的具體實現的初始化是在子類中進行的。為了解決這個問題，你可以使用預初始化欄位和懶值。

預初始化欄位：

預初始化欄位，可以讓你在初始化超類之前初始化子類的欄位。預初始化欄位用於物件或有名稱的子類時，形式如下：

class B extends {

val a = 1

} with A

預初始化欄位用於匿名類時，形式如下：

new {

val a = 1

} with A

需要注意的是：由於預初始化的欄位在超類構造器呼叫之前被初始化，因此它們的初始化器不能引用正在被構造的物件。

懶值：

加上lazy修飾符的val變數稱為懶值，懶值右側的表示式將直到該懶值第一次被使用的時候才計算。如果懶值的初始化不會產生副作用，那麼懶值定義的順序就不用多加考慮，因為初始化是按需的。

繼承與覆蓋(override)

繼承：

繼承時，如果父類主構造器帶有引數，子類需要把要傳遞的引數放在父類名之後的括號裡即可，如下：

class Second(a: Int, b: Int) extends First(a) {…}

scala繼承層級：

如上圖所示：Any是所有其他類的超類。Null是所有引用類(繼承自AnyRef的類)的子類，Null型別的值為null。Nothing是所有其他類(包括Null)的子類，Nothing型別沒有任何值，它的一個用處是它標明瞭不正常的終止（例如丟擲異常，啥也不返回）。AnyVal是scala中內建值類(共9個)的父類。AnyRef是scala中所有引用類的父類，在java平臺上AnyRef實際就是java.lang.Object的別名，因此java裡寫的類和scala裡寫的類都繼承自AnyRef，你可以認為java.lang.Object是scala在java平臺上實現AnyRef的方式。scala類與java類的不同之處在於，scala類還繼承了一個名為ScalaObject的特別記號特質，目的是想讓scala程式執行得更高效。

覆蓋：

由於scala裡欄位和方法屬於相同的名稱空間，這讓欄位可以覆蓋無引數方法或空括號方法，但反過來好像不可以啊。另外，你也可以用空括號方法覆蓋無引數方法，反之亦可。在scala中，若子類覆蓋了父類的具體成員則必須帶override修飾符；若是實現了同名的抽象成員時則override是可選的；若並未覆蓋或實現基類中的成員則禁用override修飾符。

特質(trait)

特質相當於介面，不能被例項化。特質定義使用trait關鍵字，與類相似，你同樣可以在其中定義而不僅是宣告欄位和方法等。你可以使用extends或with將多個特質“混入”類中。注意當在定義特質時，使用extends指定了特質的超類，那麼該特質就只能混入擴充套件了指定的超類的類中。

特質與類的區別在於：①特質不能帶有“類引數”，也即傳遞給主構造器的引數；②不論在類的哪個地方，super呼叫都是靜態繫結的，但在特質中，它們是動態繫結的，因為在特質定義時，尚且不知道它的超類是誰，因為它還沒有“混入”，由於在特質中使用super呼叫超類方法是動態繫結的，因此你需要對特質中相應的方法加上abstract宣告（雖然加上了abstract宣告，但方法仍可以被具體定義，這種用法只有在特質中有效），以告訴編譯器特質中的該方法只有在特質被混入某個具有期待方法的具體定義的類中才有效。你需要非常注意特質被混入的次序：特質在構造時順序是從左到右，構造器的順序是類的線性化（線性化是描述某個型別的所有超型別的一種技術規格）的反向。由於多型性，子類的方法最先起作用，因此越靠近右側的特質越先起作用，如果最右側特質呼叫了super，它呼叫左側的特質的方法，依此類推。

Ordered特質：

Ordered特質擴充套件自java的Comparable介面。Ordered特質用於排序，為了使用它，你需要做的是：首先將其混入類中，然後實現一個compare方法。需要注意的是：Ordered並沒有為你定義equals方法，因為通過compare實現equals需要檢查傳入物件的型別，但是因為型別擦除，導致它無法做到。因此，即使繼承了Ordered，也還是需要自己定義equals。

Ordering特質：

Ordering特質擴充套件自java的Comparator介面。Ordering特質也用於排序，為了使用它，你需要做的是：定義一個該特質的子類的單獨的例項，需要實現其中的compare方法，並將其作為引數傳遞給排序函式。此乃策略模式也。

Application特質：

特質Application聲明瞭帶有合適簽名的main方法。但是它存在一些問題，所以只有當程式相對簡單並且是單執行緒的情況下才可以繼承Application特質。Application特質相對於APP特質來說，有些陳舊，你應該使用更新的APP特質。

APP特質：

APP特質同Application特質一樣，都提供了帶有合適簽名的main方法，在使用時只需將它混入你的類中，然後就可以在類的主構造器中寫程式碼了，無需再定義main方法。如果你需要命令列引數，可以通過args屬性得到。

顯式型別轉換

正如之前所述的，scala中型別轉換使用方法實現，以下是顯式型別測試和顯式型別轉換的示例：

a.isInstanceOf[String] // 顯式型別測試

a.asInstanceOf[String] // 顯式型別轉換

隱式轉換、隱式引數

隱式轉換：

隱式轉換隻是普通的方法，唯一特殊的地方是它以修飾符implicit開始，implicit告訴scala編譯器可以在一些情況下自動呼叫（比如說如果當前型別物件不支援當前操作，那麼scala編譯器就會自動新增呼叫相應隱式轉換函式的程式碼，將其轉換為支援當前操作的型別的物件，前提是已經存在相應的隱式轉換函式且滿足作用域規則），而無需你去呼叫（當然如果你願意，你也可以自行呼叫）。隱式轉換函式定義如下：

implicit def functionName(…) = {…}

隱式轉換滿足以下規則：

作用域規則：scala編譯器僅會考慮處於作用域之內的隱式轉換。隱式轉換要麼是以單一識別符號的形式（即不能是aaa.bbb的形式，應該是bbb的形式）出現在作用域中，要麼是存在於源型別或者目標型別的伴生物件中。

單一呼叫規則：編譯器在同一個地方只會新增一次隱式操作，不會在添加了一個隱式操作之後再在其基礎上新增第二個隱式操作。

顯式操作先行規則：若編寫的程式碼型別檢查無誤，則不會嘗試任何隱式操作。

隱式引數：

柯里化函式的完整的最後一節引數可以被隱式提供，即隱式引數。此時最後一節引數必須被標記為implicit（整節引數只需一個implicit，並不是每個引數都需要），同時用來提供隱式引數的相應實際變數也應該標記為implicit的。對於隱式引數，我們需要注意的是：

① 隱式引數也可以被顯式提供；

② 提供隱式引數的實際變數必須以單一識別符號的形式出現在作用域中；

③ 編譯器選擇隱式引數的方式是通過匹配引數型別與作用域內的值型別，因此隱式引數應該是很稀少或者很特殊的型別（最好是使用自定義的角色確定的名稱來命名隱式引數型別），以便不會被碰巧匹配；

④ 如果隱式引數是函式，編譯器不僅會嘗試用隱式值補足這個引數，還會把這個引數當作可用的隱式操作而使用於方法體中。

視界：

視界使用“<%”符號，可以用來縮短帶有隱式引數的函式簽名。比如，“T <% Ordered[T]”是在說“任何的T都好，只要T能被當作Ordered[T]即可”，因此只要存在從T到Ordered[T]的隱式轉換即可。

注意視界與上界的不同：上界“T <: Ordered[T”是說T是Ordered[T]型別的。

隱式操作除錯：

隱式操作是scala的非常強大的特性，但有時很難用對也很難除錯。

有時如果編譯器不能發現你認為應該可以用的隱式轉換，你可以把該轉換顯式地寫出來，這有助於發現問題。

另外，你可以在編譯scala程式時，使用“-Xprint:typer”選項來讓編譯器把添加了所有的隱式轉換之後的程式碼展示出來。

型別引數化

在scala中，型別引數化(類似於泛型)使用方括號實現，如：Foo[A]，同時，我們稱Foo為高階型別。如果一個高階型別有2個型別引數，則在宣告變數型別時可以使用中綴形式來表達，此時也稱該高階型別為中綴型別，示例如下：

class Foo[A,B]

val x: Int Foo String = null // Int Foo String 等同於 Foo[Int,String]

與java相似，scala的型別引數化也使用型別擦除實現(型別擦除是很差勁的泛型機制，不過可能是由於java的原因，scala也這樣做了)，型別擦除的唯一例外就是陣列，因為在scala中和java中，它們都被特殊處理，陣列的元素型別與陣列值儲存在一起。在scala中，陣列是“不變”的(這點與java不同)，泛型預設是“不變”的。

協變、逆變與不變：

拿Queue為例，如果S是T的子型別，那麼Queue[S]是Queue[T]的子型別，就稱Queue是協變的；相反，如果Queue[T]是Queue[S]的子型別，那麼Queue是逆變的；既不是協變又不是逆變的是不變的，不變的又叫嚴謹的。

在scala中，泛型預設是不變的。當定義型別時，你可以在型別引數前加上“+”使型別協變，如Queue[+A]。類似地，你可以在型別引數前加上“-”使型別逆變。在java中使用型別時可以通過使用extends和super來達到協變逆變的目的，它們都是“使用點變型”，java不支援“宣告點變型”。而scala中同時提供了宣告點變型(“+”和“-”，它們只能在型別定義時使用)和使用點變型(“<:”和“>:”，類似於java中的extends和super，在使用型別時宣告)。不管是“宣告點變型”還是“使用點變型”，都遵循PECS法則，詳見java泛型。需要注意的是：變型並不會被繼承，父類被宣告為變型，子類若想保持仍需要再次宣告。

繼承中的協變逆變：

c++、java、scala都支援返回值協變，也就是說在繼承層次中子類覆蓋超類的方法時，可以指定返回值為更具體的型別。c#不支援返回值協變。

允許引數逆變的面嚮物件語言並不多——c++、java、scala和c#都會把它當成一個函式過載。

更多資訊參見java泛型。

集合

scala的集合（collection）庫分為可變（mutable）型別與不可變（immutable）型別。以Set為例，特質scala.collection.immutable.Set和scala.collection.mutable.Set都擴充套件自scala.collection.Set。

scala集合的頂層抽象類和特質： 

 

scala.collection.immutable：

 

scala.collection.mutable：

 

不可變集合與可變集合之間的對應關係：

不可變（collection.immutable._）	可變（collection.mutable._）
Array	ArrayBuffer
List	ListBuffer
String	StringBuilder
-	LinkedList, DoubleLinkedList
List	MutableList
Queue	Queue
Array	ArraySeq
Stack	Stack
HashMap HashSet	HashMap HashSet
-	ArrayStack

Iterable與Iterator：

Iterable是可變和不可變序列、集、對映的超特質。集合物件可以通過呼叫iterator方法來產生迭代器Iterator。Iterable與Iterator之間的差異在於：前者指代的是可以被列舉的型別，而後者是用來執行列舉操作的機制。儘管Iterable可以被列舉若干次，但Iterator僅能使用一次。

陣列：

在scala中，陣列儲存相同型別的元素，其中包含的元素值是可變的。陣列也是物件，訪問陣列使用小括號。在JVM中，scala的陣列以java陣列方式實現。scala中陣列是非協變的。

定長陣列使用Array，建立之後長度不可改變。變長陣列使用ArrayBuffer。

與java一樣，scala中多維陣列也是通過陣列的陣列來實現的。構造多維陣列可以使用ofDim方法或者直接使用for迴圈來new。示例如下：

val matrix = Array.ofDim[Double](3,4) // ofDim方法建立多維陣列

matrix(1)(2) = 12.36

val mutliarr = new Array[Array[Int]](10) // for迴圈方式建立多維陣列

for(i <- 0 until mutliarr.length)

mutliarr(i) = new Array[Int](5)

列表：

列表儲存相同型別的元素。scala裡的列表型別是協變的，這意味著如果S是T的子類，那麼List[S]也是List[T]的子類。

不可變列表使用List，一旦建立之後就不可改變。可變列表使用ListBuffer。

List是抽象類，它有兩個子型別：Nil和::。Nil是空列表物件，型別是List[Nothing]。::是樣本類，可以建立非空列表，::的伴生物件可以以中綴標註的形式用於模式匹配。所以在scala中存在兩個::，一個是樣本類，另一個是List的方法，因此在構造一個列表時，我們就有了多種方法，如下：

val list1 = List("A") // 這裡List是伴生物件，相當於 List.apply()

val list2 = ::("A",Nil) // 這裡::是伴生物件, 相當於 ::.apply()

val list3 = "A" :: Nil // 這裡::是方法, 相當於 Nil.::()

List類沒有提供append操作（向列表尾部追加），因為隨著列表變長，效率將逐漸低下。List提供了“::”做字首插入，因為這將消耗固定時間。如果你想通過新增元素來構造列表，你的選擇是先把它們字首插入，完成之後再呼叫reverse；或者使用ListBuffer，一種提供append操作的可變列表，完成之後呼叫toList。

棧和佇列：

scala集合庫提供了可變和不可變的棧類Stack，也提供了可變和不可變的佇列類Queue。

元組與對偶：

元組Tuple也是不可變的，但元組可以包含不同型別的元素，並且因此而不能繼承自Iterable。

元組例項化之後，可以使用點號、下劃線和從1開始的索引訪問其中的元素。因為元組可以儲存不同型別的元素，所以不能使用apply方法訪問其元素（apply返回同樣的型別）。元組的索引從1開始，是因為對於擁有靜態型別元組的其他語言，如Haskell和ML，從1開始是傳統的設定。

scala的任何物件都可以呼叫“->”方法，並返回包含鍵值對的二元組（也叫對偶，是元組的最簡單形態），比如 “hello” -> 100 則創建出 (“hello”, 100)。

元組相應操作示例如下：

val t = (1400, “Jim”, “haha”, 3.14) // 定義一個元組

val second = t._2 // 引用元組第二個組元

val (first, second, third, fourth) = t // 分別獲取元組的第1、2、3、4個組元

val (first, secong, _) = t // 只獲取前兩個組元

集和對映：

集中儲存著不重複的元素。對映可以把鍵和值關聯起來儲存。

拉鍊操作：

val symbols = Array(“<”, “-”, “>”)

val counts = Array(2, 10, 2)

val pairs = symbols.zip(counts)

以上程式碼生成對偶型別的陣列，如下：

Array((<,2), (-,10), (>,2))

可變集合vs不可變集合：

可變集合效能更好，不可變集合更易於理清頭緒。對於某些問題來說，可變集合能夠很好的處理；而另一些，不可變集合更為合適。如果在使用可變集合時，你發現需要擔憂何時複製可變集合的副本，或者思考很多關於誰“主宰”或“擁有”可變集合的時候，那麼請考慮是否可用不可變集合代替。

異常

scala的異常工作機制與java的類似，但也有區別。區別如下：

① scala沒有“受檢”異常——你不需要宣告函式或方法可能會丟擲某種異常。

② throw表示式是有值的，其值是Nothing型別。

③ try-catch-finally表示式也是有值的，但是情況有些特殊。當沒有丟擲異常時，try子句為表示式值；如果丟擲異常並被捕獲，則對應於相應的catch子句；如果沒有被捕獲，表示式就沒有返回值。finally子句計算得到的值，總是被拋棄（除非使用return語句），所以你應該在finally子句中幹一些它應該乾的事，比如說：關閉檔案、套接字、資料庫連線等，而最好別幹什麼其他事。

斷言、檢查

scala裡，斷言使用assert函式，檢查使用ensuring函式，如果條件不成立，它們將會丟擲AssertionError。它們都在Predef中定義。你可以使用JVM的-ea和-da命令列標誌來開放和禁止斷言以及檢查。

包和引用

打包：

scala的程式碼採用了java平臺完整的包機制。你可以使用兩種方式把程式碼放進包裡：

① 使用放在檔案頂部的package子句來把整個檔案放入包中；

② 使用package子句把要放入到包中的程式碼用花括號括起來，這種方式像C#的名稱空間。使用這種方式，你可以定義出巢狀的包，注意：scala的包可以巢狀，java則不可以。任何你自己寫的頂層包都被隱含地包含在_root_包中，因此你可以在多層巢狀的包程式碼中通過_root_來訪問頂層包中的程式碼。

引用：

與java類似，scala使用import來引用，與java不同的是，scala的import子句：

① 可以出現在任何地方，而不僅僅在檔案開始處；

② 可以引用物件和包；

③ 可以重新命名或隱藏一些被引用的成員。這可以通過在被引用成員的物件之後加上括號裡的引用選擇器子句來做到，示例如下（令p為包名）：

import p.{x} // 從p中引入x，等價於 import p.x

import p.{x => y} // 從p中引入x，並重命名為y

import p.{x => _, _} // 從p中引入除了x之外的所有東東。注意單獨的“_”稱作全包括，必須位於選擇器的最後。import p.{_} 等價於 import p._

隱式引用：

scala隱含地為每個原始檔都加入如下引用：

import java.lang._

import scala._

import Predef._

包scala中的Predef物件包含了許多有用的方法。例如：通常我們所使用的println、readLine、assert等。

scala I/O

由於scala可以和java互操作，因此目前scala中的I/O類庫並不多，你可能需要使用java中的I/O類庫。下面介紹scala中有的東東：

scala.Console物件可以用於終端輸入輸出，其中終端輸入函式有：readLine、readInt、readChar等等，終端輸出函式有：print、println、printf等等。其實，Predef物件中提供的預定義的readLine、println等等方法都是Console物件中對應方法的別名。

scala.io.Source可以以文字的方式迭代地讀取原始檔或者其他資料來源。用完之後記得close啊。

物件序列化：

為了讓物件可序列化，你可以這樣定義類：

@SerialVersionUID(42L) class Person extends Serializable {…}

其中，@SerialVersionUID註解指定序列化ID，如果你能接受預設的ID，也可省去該註解；Serializable在scala包中，因此你無需引入。你可以像java中一樣對物件進行序列化。scala集合類都是可以序列化的，因此你可以把它們作為你的可序列化類的成員。

Actor和併發

與java的基於共享資料和鎖的執行緒模型不同，scala的actor包則提供了另外一種不共享任何資料、依賴訊息傳遞的模型。設計併發軟體時，actor是首選的工具，因為它們能夠幫助你避開死鎖和爭用狀況，這兩種情形都是在使用共享和鎖模型時很容易遇到的。

建立actor：

actor是一個類似於執行緒的實體，它有一個用來接收訊息的郵箱。實現actor的方法是繼承scala.actors.Actor特質並完成其act方法。你可以通過actor的start方法來啟動它。actor在執行時都是相互獨立的。你也可以使用scala.actors.Actor物件的actor方法來建立actor，不過此時你就無需再呼叫start方法，因為它在建立之後馬上啟動。

傳送接收訊息：

Actor通過相互發送訊息的方式進行通訊，你可以使用“!”方法來發送訊息，使用receive方法來接收訊息，receive方法中包含訊息處理的模式匹配(偏函式)。傳送訊息並不會導致actor阻塞，傳送的訊息在接收actor的郵箱中等待處理，直到actor呼叫了receive方法，如果actor呼叫了receive但沒有模式匹配成功的訊息，那麼該actor將會阻塞，直到收到了匹配的訊息。建立actor併發送接收訊息的示例如下：

object ScalaTest extends Actor {

def act() {

while (true) {

receive {

case msg => println(msg)

}

}

}

def main(args: Array[String]) {

start()

this ! "hello."

}

}

將原生執行緒當作actor：

Actor子系統會管理一個或多個原生執行緒供自己使用。只要你用的是你顯式定義的actor，就不需要關心它們和執行緒的對應關係是怎樣的。該子系統也支援反過來的情形：即每個原生執行緒也可以被當作actor來使用。此時，你應該使用Actor.self方法來將當前執行緒作為actor來檢視，也就是說可以這樣使用了：Actor.self ! "message"。

通過重用執行緒獲取更好的效能：

Actor是構建在普通java執行緒之上的，如果你想讓程式儘可能高效，那麼慎用執行緒的建立和切換就很重要了。為幫助你節約執行緒，scala提供了react方法，和receive一樣，

相關推薦