Scala 學習一

1.IDEA新建scala相關文檔

https://www.jetbrains.com/help/idea/2016.3/creating-and-running-your-scala-application.html

2.Scanla 變量

變量的類型在變量名之後等號之前聲明。定義變量的類型的語法格式如下：

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

變量聲明不一定需要初始值

var myVar :Int;
val myVal :String;

在 Scala 中聲明變量和常量不一定要指明數據類型，在沒有指明數據類型的情況下，其數據類型是通過變量或常量的初始值推斷出來的。

所以，如果在沒有指明數據類型的情況下聲明變量或常量必須要給出其初始值，否則將會報錯。

Scala 多個變量聲明

val xmax, ymax = 100  // xmax, ymax都聲明爲100

如果方法返回值是元組，我們可以使用 val 來聲明一個元組：

val (myVar1: Int, myVar2: String) = Pair(40, "Foo")

val (myVar1, myVar2) = Pair(40, "Foo")

3.Scala 訪問修飾符

Scala 訪問修飾符基本和Java的一樣，分別有：private，protected，public。

如果沒有指定訪問修飾符符，默認情況下，Scala對象的訪問級別都是 public。

Scala 中的 private 限定符，比 Java 更嚴格，在嵌套類情況下，外層類甚至不能訪問被嵌套類的私有成員。

私有(Private)成員

用private關鍵字修飾，帶有此標記的成員僅在包含了成員定義的類或對象內部可見，同樣的規則還適用內部類。

class Outer{
    class Inner{
    private def f(){println("f")}
    class InnerMost{
        f() // 正確
        }
    }
    (new Inner).f() //錯誤
}

(new Inner).f( ) 訪問不合法是因爲 f 在 Inner 中被聲明爲 private，而訪問不在類Inner之內。

但在 InnerMost 裏訪問f就沒有問題的，因爲這個訪問包含在 Inner 類之內。

Java中允許這兩種訪問，因爲它允許外部類訪問內部類的私有成員。

保護(Protected)成員

在 scala 中，對保護（Protected）成員的訪問比 java 更嚴格一些。因爲它只允許保護成員在定義了該成員的的類的子類中被訪問。而在java中，用protected關鍵字修飾的成員，除了定義了該成員的類的子類可以訪問，同一個包裏的其他類也可以進行訪問。

公共(Public)成員

Scala中，如果沒有指定任何的修飾符，則默認爲 public。這樣的成員在任何地方都可以被訪問。

作用域保護

Scala中，訪問修飾符可以通過使用限定詞強調。格式爲:

private[x] 

或 

protected[x]

這裏的x指代某個所屬的包、類或單例對象。如果寫成private[x],讀作"這個成員除了對[…]中的類或[…]中的包中的類及它們的伴生對像可見外，對其它所有類都是private。

這種技巧在橫跨了若干包的大型項目中非常有用，它允許你定義一些在你項目的若干子包中可見但對於項目外部的客戶卻始終不可見的東西。

package bobsrocckets{

    package navigation{

        private[bobsrockets] class Navigator{

         protected[navigation] def useStarChart(){}
         class LegOfJourney{
             private[Navigator] val distance = 100
             }
            private[this] var speed = 200
            }

        }

        package launch{
        import navigation._
        object Vehicle{
        private[launch] val guide = new Navigator
        }

    }

}

上述例子中，類Navigator被標記爲private[bobsrockets]就是說這個類對包含在bobsrockets包裏的所有的類和對象可見。

比如說，從Vehicle對象裏對Navigator的訪問是被允許的，因爲對象Vehicle包含在包launch中，而launch包在bobsrockets中，相反，所有在包bobsrockets之外的代碼都不能訪問類Navigator。

4.Scala 循環

Scala 語言提供了以下幾種循環類型。和java略有不同.

4.1 scala-for-loop FOR

語法:

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

請注意，條件表達式出現在循環的尾部，所以循環中的 statement(s) 會在條件被測試之前至少執行一次。

如果條件爲 true，控制流會跳轉回上面的 do，然後重新執行循環中的 statement(s)。

這個過程會不斷重複，直到給定條件變爲 false 爲止。

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

基礎實例

以下是一個使用了 i to j 語法(包含 j)的實例:

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

result:
value of a: 1
value of a: 2
value of a: 3
value of a: 4
value of a: 5
value of a: 6
value of a: 7
value of a: 8
value of a: 9
value of a: 10

以下是一個使用了 i until j 語法(不包含 j)的實例:

object Test {
   def main(args: Array[String]) {
      var a = 0;
      // for 循環,until 不含10
      for( a <- 1 until 10){
         println( "Value of a: " + a );
      }
   }
}

reuslt:
value of a: 1
value of a: 2
value of a: 3
value of a: 4
value of a: 5
value of a: 6
value of a: 7
value of a: 8
value of a: 9

在 for 循環 中你可以使用分號 (;) 來設置多個區間，它將迭代給定區間所有的可能值。以下實例演示了兩個區間的循環實例：

//說明:先取從左第一個區間的值,輪詢第二區間的循環,完畢,繼續從左第二個....以此類推
for( a <- 1 to 3; b <- 1 to 3){
     println( "Value: " + a +"-"+b )
}

result:
Value: 1-1
Value: 1-2
Value: 1-3
Value: 2-1
Value: 2-2
Value: 2-3
Value: 3-1
Value: 3-2
Value: 3-3

for 循環集合

object HelloWorld {

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

    val numList = List(1, 2, 3)
    for (a <- numList) {
      println(a)
    }

  }

}

result:
1
2
3

for 循環過濾

Scala 可以使用一個或多個 if 語句來過濾一些元素。以下是在 for 循環中使用過濾器的語法。你可以使用分號(;)來爲表達式添加一個或多個的過濾條件。

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

實例:

 val numList = List(1, 2, 3)
    for (a <- numList
         if a != 1; if a != 2) {
      println(a)
    }

result:  3

for 使用 yield

你可以將 for 循環的返回值作爲一個變量存儲。語法格式如下：

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

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

可以將yield x 理解爲臨時存儲對象.

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

    val numList = List(1, 2, 3, 4, 5, 6)
    val result = for {a <- numList
                      if a != 1; if a != 2} yield a

    for (b <- result) {
      println(b)
    }
  }

result:
3
4
5
6

4.2 Scala do...while和while 循環

不像 while 循環在循環頭部測試循環條件, Scala 語言中，do...while 循環是在循環的尾部檢查它的條件。

do...while 循環與 while 循環類似，但是 do...while 循環會確保至少執行一次循環。其實和java一樣

var a = 10

    do {
      println(a)
      a = a + 1
    } while (a < 15)

result:
10
11
12
13
14

下面是while,也和java一樣

var a = 15

    while (a < 20) {
      println(a)
      a = a + 1
    }

result:
15
16
17
18
19

4.3 Scala break 語句

Scala 中 break 的語法有點不大一樣，格式如下：

// 導入以下包
import scala.util.control._

// 創建 Breaks 對象
val loop = new Breaks;

// 在 breakable 中循環
loop.breakable{
    // 循環
    for(...){
       ....
       // 循環中斷
       loop.break;
   }
}

實例1:

var a = 0;
      val numList = List(1,2,3,4,5,6,7,8,9,10);

      val loop = new Breaks;
      loop.breakable {
         for( a <- numList){
            println( "Value of a: " + a );
            if( a == 4 ){
               loop.break;
            }
         }
      }
      println( "After the loop" );

實例2:

val numList1 = List(1, 2)
    val numList2 = List(11, 12, 13)

    val inner = new Breaks
    for (a <- numList1) {

      println("a: " + a)

      inner.breakable {

        for (b <- numList2) {
          println("b: " + b)
          if (b == 12) {
            inner.break
          }
        }

      }
    }

result:
a: 1
b: 11
b: 12
a: 2
b: 11
b: 12