Scala学习（一）

1. Scala变量

a. 变量，使用关键字 "var"。常量使用关键字"val"

b. 变量类型声明：

var VariableName : DataType [=  Initial Value]

或

val VariableName : DataType [=  Initial Value]

2. Scala 访问修饰符

private:带有此标记修饰的成员仅在包含了成员定义的类或对象内部可见，同样的规则还适用于内部类。

class Outer{
    class Inner{
    private def f(){println("f")}
    class InnerMost{
        f() // 正确
        }
    }
    (new Inner).f() //错误
}

protected:比Java要严格一些，只允许在定义了该成员的类的子类中被访问。

3. Scala 函数

Scala 函数定义格式如下：

def functionName ([参数列表]) : [return type] = {
   function body
   return [expr]
}

函数式变成是scala语言的核心，主要分为函数传名调用、指定函数参数名、函数-可变参数、递归函数、默认参数值、高阶函数、内嵌函数、匿名函数、偏应用函数、函数柯里化

3.1 函数传名调用

函数的形参从 paraName:Type 变成 paraName: =>Type，表示在传入改参数时不计算，在正真调用的时候再计算。结果表明，fun3在调用前会先去计算fun1的值。

object ScalaApp {

  def fun1():Long = {
    println("fun1")
    return System.currentTimeMillis();
  }

  def fun2(t: =>Long )={     //函数传名调用
    println("fun2")
    println(t)
  }

  def fun3(t:Long)={         //函数传值调用
    println("fun3")
    println(t)
  }

  def main(args: Array[String]): Unit = {
    fun2(fun1)
    println("--------------")
    fun3(fun1)
  }
}

输出结果：

fun2
fun1
1490334605854
--------------
fun1
fun3
1490334605854

3.2 指定参数名

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 );
   }
}

3.3 可变参数

Scala 通过在参数的类型之后放一个星号(*)来设置可变参数(可重复的参数)

3.4 闭包

闭包是一个函数，返回值依赖于声明在函数外部的一个或多个变量。

如一个匿名函数：val bifun = (t:Long) => t*10，下面函bifun就是一个闭包，可以通过访问函数外面的变量。

var param = 10
val bifun = (t:Long) => t*param

4. 基本类型和操作

4.1 对象相等

== 不仅仅对基本类型有效，对列表也有效

List(1,2,3) == List(1,2,3)

5. 类和对象

5.1 从构造器

有些时候一个类需要多个构造器，Scala里主构造器之外的构造器被称为从构造器

class A(para_a:Int,para_b:AnyVal) {
  private val a = para_a;
  def this()=this(0,0)       //从构造器
  def fun():Int = {
    return 1
  }
}

5.2 定义操作符

class A{
  def + (a:Int): Unit ={  
  }
}

6. 使用try处理异常

def fun() ={
    try{
      throw new NullPointerException("")
    }catch{
      case ex:NullPointerException => ex.printStackTrace()
      case ex:Exception => ex.printStackTrace()
    }
  }

关于finally，在Java里，如果finally子句中包含一个显式返回语句，或抛出一个异常，那么这个返回值会凌驾于之前try代码块或catch子句产生的Exception之上。如：

def f():Int = try{return 1}finally{return 2} //调用f()产生的结果值是2。相反：

def g():Int = try{1}finally{2} //调用g()产生的结果值是1

所以，还是尽量避免在finally中包含返回值。

7. match表达式

val str = "ab"
    str match {
      case "a" => println("is a")
      case "b" => println("is b")
    }

8. 柯里化（Curry)

def sum(x:Int, y:Int) = x + y

def curriedSum(x:Int)(y:Int) = x + y //柯里函数

>: curriedSum(1)(2)

这里你调用柯里函数curriedSum，你实际上调用了两个传统函数。第一个函数调用带单个名为x的Int参数，并返回第二个函数的函数值。第二个函数带Int参数y。下面名为first的函数实质上执行了curriedSum函数的第一个传统函数会做的事情：

def first(x:Int) = (y:Int) => x+y //curriedSum的第一个函数返回的是一个函数