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