1.scala是一種純面向對象的語言，每個值都是對象。對象的數據類型以及行為由類和特質描述

2.類的擴展有2種機制：繼承和混入機制

3.scala是一種函數式語言，其函數也能當成值來使用

==4.scala使用actor作為其並發模型，actor是類似線程的實體，通過郵箱發收消息。actor可以復用線程，因此在程序中可用數百萬個actor，而線程只能創建數千個==

5.scala與java語法最大的區別是：scala語句末尾的分號是可選的

6.所有類名首字母大寫，方法名首字母小寫，程序文件名與對象名稱可以不匹配，但建議保留匹配的習慣;def main(args: Array[String]),scala程序從main()方法開始處理

7.Unit表示無值，同void.Unit只有一個實例值，寫成()

8.Nothing類型在scala的類層級的最低端，它是任何其它類型的子類型

9.Any是所有其它類的超類

10.AnyRef類是scala裏所有引用類的基類

11.符號字面量‘<標識符>被映射成預定義類scala.Symbol的實例

如： 符號字面量 ‘x 是表達式 scala.Symbol("x") 的簡寫，符號字面量定義如下：

package scala
final case class Symbol private (name: String) {
   override def toString: String = "'" + name
}
 

12.多行字符串用三個雙引號來表示分割符，實例如下：

val foo = """菜鳥教程
www.runoob.com
www.w3cschool.cc
www.runnoob.com
以上三個地址都能訪問"""

13.var聲明變量，val聲明常量，修改常量時會在編譯時報錯

14.變量類型聲明一定要有初始值，否則會報錯

var VariableName : DataType [=  Initial Value]
或
val VariableName : DataType [=  Initial Value]

15.默認情況下訪問級別是==public==

16.scala中的函數其實就是繼承了trait的類對象，scala中使用val語句定義函數，def定義方法

def functionName ([參數列表]) : [return type]

17.scala在函數調用的時候，可以通過指定參數名，並且不按照順序向函數傳遞參數，實例如下:

object Test {
   def main(args: Array[String]) {
        printInt(b=5, a=7);
   }
   def printInt( a:Int, b:Int ) = {
      println("Value of a : " + a );
      println("Value of b : " + b );
   }
}

18.for語法

18.1.Range風格的for循環

for( var x <- Range ){
   statement(s);
}

以上語法中，Range 可以是一個數字區間表示 i ==to== j ，或者 i ==until== j。左箭頭 ==<-== 用於為變量 x 賦值。

i to j 包含j
i until j 不包含j

18.2.分號(;)風格的for循環，可以設置多個區間同時循環，即==多重循環==,實例:

object Test {
   def main(args: Array[String]) {
      var a = 0;
      var b = 0;
      // for 循環
      for( a <- 1 to 3; b <- 1 to 3){
         println( "Value of a: " + a );
         println( "Value of b: " + b );
      }
   }
}

輸出結果:

Value of a: 1
Value of b: 1
Value of a: 1
Value of b: 2
Value of a: 1
Value of b: 3
Value of a: 2
Value of b: 1
Value of a: 2
Value of b: 2
Value of a: 2
Value of b: 3
Value of a: 3
Value of b: 1
Value of a: 3
Value of b: 2
Value of a: 3
Value of b: 3

18.3.for遍歷集合，語法:

for( var x <- List ){
   statement(s);
}

實例：

object Test {
   def main(args: Array[String]) {
      var a = 0;
      val numList = List(1,2,3,4,5,6);

      // for 循環
      for( a <- numList ){
         println( "Value of a: " + a );
      }
   }
}

18.4.for循環過濾,語法:

for( var x <- List
      if condition1; if condition2...
   ){
   statement(s);

實例:

object Test {
   def main(args: Array[String]) {
      var a = 0;
      val numList = List(1,2,3,4,5,6,7,8,9,10);

      // for 循環
      for( a <- numList
           if a != 3; if a < 8 ){
         println( "Value of a: " + a );
      }
   }
}

18.5.for循環使用yield將循環過濾的返回值用作變量存儲，語法：

var retVal = for{ var x <- List
     if condition1; if condition2...
}yield x

大括號用於保存變量和條件，retVal是變量，循環中的yield會把當前的元素記下來，保存在集合中，循環結束後將返回該集合。實例:

object Test {
   def main(args: Array[String]) {
      var a = 0;
      val numList = List(1,2,3,4,5,6,7,8,9,10);

      // for 循環
      var retVal = for{ a <- numList 
                        if a != 3; if a < 8
                      }yield a

      // 輸出返回值
      for( a <- retVal){
         println( "Value of a: " + a );
      }
   }
}

執行結果:

value of a: 1
value of a: 2
value of a: 4
value of a: 5
value of a: 6
value of a: 7

19.scala允許最後一個參數是可以重復的，通過在參數的類型之後放一個星號來設置可變參數，例如:

object Test {
   def main(args: Array[String]) {
        printStrings("Runoob", "Scala", "Python");
   }
   def printStrings( args:String* ) = {
      var i : Int = 0;
      for( arg <- args ){
         println("Arg value[" + i + "] = " + arg );
         i = i + 1;
      }
   }
}

執行結果為：

Arg value[0] = Runoob
Arg value[1] = Scala
Arg value[2] = Python

20. scala偏應用函數是一種表達式，你不需要提供函數所需要的所有參數，只需要提供部分參數，或不提供所需參數，例如：

import java.util.Date

object Test {
   def main(args: Array[String]) {
      val date = new Date
      val logWithDateBound = log(date, _ : String)

      logWithDateBound("message1" )
      Thread.sleep(1000)
      logWithDateBound("message2" )
      Thread.sleep(1000)
      logWithDateBound("message3" )
   }

   def log(date: Date, message: String)  = {
     println(date + "----" + message)
   }
}

輸出結果為：

Mon Dec 02 12:53:56 CST 2013----message1
Mon Dec 02 12:53:56 CST 2013----message2
Mon Dec 02 12:53:56 CST 2013----message3

21. 在scala中無法直接操作方法，如果要操作方法，必須先將其轉換成函數。有兩種方法轉換成函數：

val f1 = m _

==在方法名稱m後面緊跟一個空格和下劃線告訴編譯器將方法m轉換成函數，而不是要調用這個方法。也可以顯示地告訴編譯器需要將方法轉換成函數：==

val f1:(Int) => Int = m

22.閉包是一個函數，返回值依賴於聲明在函數外部的一個或多個變量。如：

var factor = 3  
val multiplier = (i:Int) => i * factor  

這裏我們引入的一個自由變量factor，這個變量定義在函數外面，這樣定義的函數變量multiplier成為一個“閉包”，因為它引用到函數外面的定義的變量，定義這個函數的過程是將這個自由變量捕獲而構成一個封閉的函數。完整實例:

object Test {  
   def main(args: Array[String]) {  
      println( "muliplier(1) value = " +  multiplier(1) )  
      println( "muliplier(2) value = " +  multiplier(2) )  
   }  
   var factor = 3  
   val multiplier = (i:Int) => i * factor  
}  

輸出結果：

muliplier(1) value = 3  
muliplier(2) value = 6  

23.數組的定義與引用

一維數組創建

var z:Array[String] = new Array[String](3)
或
var z = new Array[String](3)
或
var z = Array("Runoob", "Baidu", "Google")

==引用第i元素,註意是(),而不是[]==

var myList = Array(1.9, 2.9, 3.4, 3.5)
println(myList(i))

多維數組定義

var myMatrix = ofDim[Int](3,3)

數組詳細介紹

24.scala集合分為可變集合和不可變集合，對可變集合本身可以進行增刪改操作，對不可變集合進行增刪改操作時，會返回一個新的集合，同時保證原有集合不發生改變。

集合詳細介紹

25.默認情況下scala使用不可變Map,如果你要使用可變集合，你需要顯式引入import scala.collection.mutable.Map類，在scala中你可以同時使用可變與不可變Map,可變的使用mutable.Map.

初始化不可變Map:

// 空哈希表，鍵為字符串，值為整型
var A:Map[Char,Int] = Map()

// Map 鍵值對演示
val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")

添加key-value對，使用+號，如下:

A += ('I' -> 1)
A += ('J' -> 5)
A += ('K' -> 10)
A += ('L' -> 100)

Map可以使用++運算符或者Map.++()方法來連接兩個Map,==Map合並時會移除重復的key==.

26.元組也是不可變的，但與列表不同的是元組可以包含不同類型的元素，元組的值是通過將單個的值包含在圓括號中構成的。例如：

val t = (1, 3.14, "Fred")  

以上實例在元組中定義了三個元素，對應的類型分別為[Int, Double, java.lang.String]。也可以使用以上方式來定義:

val t = new Tuple3(1, 3.14, "Fred")

元組的實際類型取決於它的元素的類型，比如 (99, "runoob") 是 Tuple2[Int, String]。 (‘u‘, ‘r‘, "the", 1, 4, "me") 為 Tuple6[Char, Char, String, Int, Int, String]。

27.==目前scala支持的元組最大長度為22.對於更大長度可以使用集合，或者擴展元組。==

28.訪問元組的元素可以通過數字索引，如：

val t = (4,3,2,1)

我們可以使用t._1訪問第一個元素，t._2訪問第二個元素;

29.Scala Option(選項)類型用來表示一個值是可選的（有值或無值)。Option[T] 是一個類型為 T 的可選值的容器： 如果值存在， Option[T] 就是一個 Some[T] ，如果不存在， Option[T] 就是對象 None 。如：

// 雖然 Scala 可以不定義變量的類型，不過為了清楚些，我還是
// 把他顯示的定義上了
 
val myMap: Map[String, String] = Map("key1" -> "value")
val value1: Option[String] = myMap.get("key1")
val value2: Option[String] = myMap.get("key2")
 
println(value1) // Some("value1")
println(value2) // None

30.在類中重寫一個非抽象方法必須使用override修飾符；只有主構造函數才可以往基類的構造函數裏寫參數；在子類中重寫超類的抽象方法時，你不需要使用override關鍵字。

31.==在 Scala 中，是沒有 static 這個東西的，但是它也為我們提供了單例模式的實現方法，那就是使用關鍵字 object。Scala 中使用單例模式時，除了定義的類之外，還要定義一個同名的 object 對象，它和類的區別是，object對象不能帶參數。當單例對象與某個類共享同一個名稱時，他被稱作是這個類的伴生對象：companion object。你必須在同一個源文件裏定義類和它的伴生對象。類被稱為是這個單例對象的伴生類：companion class。類和它的伴生對象可以互相訪問其私有成員。==

單例對象實例:

/* 文件名：Marker.scala
 * author:菜鳥教程
 * url:www.runoob.com
 */

// 私有構造方法
class Marker private(val color:String) {

  println("創建" + this)
  
  override def toString(): String = "顏色標記："+ color
  
}

// 伴生對象，與類共享名字，可以訪問類的私有屬性和方法
object Marker{
  
    private val markers: Map[String, Marker] = Map(
      "red" -> new Marker("red"),
      "blue" -> new Marker("blue"),
      "green" -> new Marker("green")
    )
    
    def apply(color:String) = {
      if(markers.contains(color)) markers(color) else null
    }
  
    
    def getMarker(color:String) = { 
      if(markers.contains(color)) markers(color) else null
    }
    def main(args: Array[String]) { 
        println(Marker("red"))  
        // 單例函數調用，省略了.(點)符號  
        println(Marker getMarker "blue")  
    }
}

32.trait（特征）相當於Java的接口，與接口不同的是，它還可以定義屬性和方法的實現

scala筆記，主要摘自網絡教程