Scala学习笔记（一）

一、变量

获取变量的值是一个耗时的工作时，可以考虑使用lazy var. 
lazy val forLater = someTimeConsumingOperation()

 

二、函数定义

“=”并不只是用来分割函数签名和函数体的，它的另一个作用是告诉编译器是否对函数的返回值进行类型推断！如果省去=,则认为函数是没有返回值的！

比如：

scala> def myFirstMethod() = { “exciting times ahead” } 
myFirstMethod: ()java.lang.String

 

scala> def myFirstMethod(){ “exciting times ahead” } 
myFirstMethod: ()Unit

 

三、方法调用

注：和本文的其他部分不同，该章节总结自《Learning Scala》一书：Methods and Operators一节，因为《Scala In Action》一书没有集中对这个知识点的讲解

通常，scala和其他大多数的语言一样，对方法的调用使用是：infix dot notation格式，我们可以叫“小数点中辍格式”，也就是对象和方法名中间以“小数点”做中缀的方式：

<class instance>.<method>[(<parameters>)]

与此同时，scala还提供了另外一种方法调用方式：infix operator notation格式，我们可以叫“操作符中辍格式”，也就是把方法名当做一种操作符，使用对象 方法名 参数中间以空格分隔的方式：

<object> <method> <parameter>

 这我们思考一下为什么会出现这种样式的方法调用，应该说这是用于引入了“操作符做方法名”而产生的一种自然需要！实际上，scala中允许使用操作符做方法名基本上与C++中的操作符重载是一样的！

scala> val d = 65.642
d: Double = 65.642
scala> d.round
res13: Long = 66
scala> d.floor
res14: Double = 65.0
scala> d.compare(18.0)
res15: Int = 1
//对于Double类型，"+"是一个方法名。
scala> d.+(2.721)
res16: Double = 68.363

 很显然，当我们引入了操作符重载之后，如果再使用“对象.方法名（参数）”的方式调用方法会看上去非常古怪，也就是这里的d.+(2.721)，此时就是使用infix operator notation样式的合适场所！

当然，这种调用样式并不是一定要使用在以操作符为方法名的方法上，如果你习惯，也可以使用在普通方法上。

 

 四、数组以及基本操作

scala> val array = new Array[String](3)
array: Array[String] = Array(null, null, null)
scala> array(0) = "This"
scala> array(1) = "is"
scala> array(2) = "mutable"

 对于给数组赋值的语句：array(0) = “This”，这里要说明的是：不同于java中的array[0] = “This” 在scala中，[]永远是用来制定参数类型的！

迭代Array的操作是非常简单的，我们只需要使用它的foreach方法，同时传递一个函数字面量即可。下面典型的例子是在迭代main函数的args参数列表：

scala> array.foreach(println)
This
is
mutable

 

 五、FOR循环

 

val files = new java.io.File(".").listFiles
    for(file <- files) {
    val filename = file.getName
    if(fileName.endsWith(".scala")) println(file)
}

 

scala> val aList = List(1, 2, 3)
aList: List[Int] = List(1, 2, 3)
scala> val bList = List(4, 5, 6)
bList: List[Int] = List(4, 5, 6)
scala> for { a <- aList; b <- bList } println(a + b)
5
6
7
6
7
8
7
8
9  
//yield直译是“产出”的意思，这里yield是专指把一个一个的元素加入到一个集合中去！
scala> val result = for { a <- aList; b <- bList } yield a + b
result: List[Int] = List(5, 6, 7, 6, 7, 8, 7, 8, 9)
scala> for(r <- result) println(r)
5
6
7
6
7
8
7
8
9 

 

 六、模式匹配：Pattern Matching

模式匹配，示例一：

ordinal(args(0).toInt)
def ordinal(number:Int) = number match {
    case 1 => println("1st")
    case 2 => println("2nd")
    case 3 => println("3rd") 
    case 4 => println("4th")
    case 5 => println("5th")
    case 6 => println("6th")
    case 7 => println("7th")
    case 8 => println("8th")
    case 9 => println("9th")
    case 10 => println("10th")
    case _ => println("Cannot do beyond 10")
} 

 

模式匹配，示例二：

在下面的这个例子中展示了scala一些内置的预定义的Pattern，专门应用于case上的，例如下面例子中的：f，s, rest

scala> List(1, 2, 3, 4) match {
case f :: s :: rest => List(f, s)
case _ => Nil
}
res7: List[Int] = List(1, 2)  

 

模式匹配，示例三： 

val suffixes = List("th", "st", "nd", "rd", "th", "th", "th","th", "th","th");
println(ordinal(args(0).toInt))
def ordinal(number:Int) = number match {
    case tenTo20 if 10 to 20 contains tenTo20 => number + "th"
    case rest => rest + suffixes(number % 10)
}

 

 七、类 Class

What val and var do is define a field and a getter for that field, and in the case of var an additional setter method is also created. When both of them are missing, they’re treated as private instance values, not accessible to anyone outside the class. 
对于Class的field的修饰符有如下约定：

1. 使用var声明field,则该field将同时拥有getter和setter 
   scala> class MongoClient(var host:String, var port:Int)

2. 使用val声明field,则该field只有getter。这意味着在初始化之后，你将无法再修改它的值。 
   scala> class MongoClient(val host:String, val port:Int)

3. 如果没有任何修饰符，则该field是完全私有的。 
   scala> class MongoClient(host:String, port:Int)

八、构造函数

主构造函数：Primary Constructor

scala的主构造函数指的是在定义Class时声明的那个函数！简单的例子：

<scala> class MongoClient(val host:String, val port:Int)

对于这个class的定义，实际上它也是同时声明了一个构造函数：this(val host:String, val port:Int), 它就是所谓的主构造函数！

关于构造函数重载

在scala中，构造函数的重载和普通函数的重载是基本一样的，区别只是构造函数使用this关键字指代！当然，也不能指定返回值。

对于重载构造函数：它的第一个语句必须是调用另外一个重载的构造函数或者是主构造函数！当然除了主构造函数以外！这个表述如果再深入地一想，那么我们就可以想到：所有的构造函数在一开始就会首先调用主函数！！这也是为什么：scala对写在Class内的零星的脚本和代码片段的处理是通过移到主构造函数内去执行的原因！

 

九、scala类结构图