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