Scala基础语法

变量和常量

在scala中关键字var表示变量，val表示常量，使用常量可以增强代码可读性，减少变量重复使用的可能
值得注意的是，Scala行末没有分号，但如果一行里有多条语句，分号则是必要的

var numberOfKittens = 6
val kittensPerHouse = 101
val alphabet = "abcdefghijklmnopqrstuvwxyz"
var done = false

numberOfKittens += 1

// kittensPerHouse = kittensPerHouse * 2 // kittersPerHouse是不可重载的，所以这一行会导致不能编译

println(alphabet)
done = true

条件语句

Scala的条件语句和其他语言类似，单行语句可以不用{}包围，但多行语句需使用大括号


// A simple conditional; by the way, this is a comment// A si 
if (numberOfKittens > kittensPerHouse) { 
    println("Too many kittens!!!") 
}
// The braces are not required when all branches are one liners. However, the 
// Scala Style Guide prefers brace omission only if an "else" clause is included.
// (Preferably not this, even though it compiles...)
if (numberOfKittens > kittensPerHouse) 
    println("Too many kittens!!!")

// ifs have else clauses, of course
// This is where you can omit braces!
if (done) 
    println("we are done")
else 
    numberOfKittens += 1

// And else ifs
// For style, keep braces because not all branches are one liners. 
if (done) {
    println("we are done")
}
else if (numberOfKittens < kittensPerHouse) {
    println("more kittens!")
    numberOfKittens += 1
}
else {
    done = true
}

Scala中的if语句是有返回值的，他的返回值是所执行if分支的最后一条语句

valval  likelyCharactersSetlikelyC  = if (alphabet.length == 26)
    "english"
else 
    "not english"

println(likelyCharactersSet)

方法和函数

函数的声明

方法的关键词是def，他的参数表是由逗号分开的，参数均为参数名:类型的形式其后接上返回值的类型，如下：

// Simple scaling function with an input argument, e.g., times2(3) returns 6
// Curly braces can be omitted for short one-line functions.
def times2(x: Int): Int = 2 * x

// More complicated function
def distance(x: Int, y: Int, returnPositive: Boolean): Int = {
    val xy = x * y
    if (returnPositive) xy.abs else -xy.abs
}

没有参数的函数可以不写括号，按照惯例，没有任何副作用，仅仅返回值的函数不写括号；但是改变了外部参数，有标准输出等存在副作用的无参函数要写括号

函数的重载

同样的函数名可以通过不同的参数类型进行重载，如下：

// Overloaded function
def times2(x: Int): Int = 2 * x
def times2(x: String): Int = 2 * x.toInt

times2(5)
times2("7")

子函数和递归调用

函数内部可以声明子函数，但其子函数只在当前函数内可见

/** Prints a triangle made of "X"s/** Pri 
  * This is another style of comment
  */
def asciiTriangle(rows: Int) {
    
    // This is cute: multiplying "X" makes a string with many copies of "X"
    def printRow(columns: Int): Unit = println("X" * columns)
    
    if(rows > 0) {
        printRow(rows)
        asciiTriangle(rows - 1) // Here is the recursive call
    }
}

// printRow(1) // This would not work, since we're calling printRow outside its scope
asciiTriangle(6)

列表

列表和数组有一些区别，列表可以支持添加和提取等操作

val x = 7
val y = 14
val list1 = List(1, 2, 3)
val list2 = x :: y :: y :: Nil       // list2里面有x, y, y三个元素，Nil表示列表结束

val list3 = list1 ++ list2           //把第二个列表添加到第一个列表之后
val m = list2.length
val s = list2.size

val headOfList = list1.head          // 取得列表第一个元素
val restOfList = list1.tail          // 取得列表除去第一个元素后的所有元素

val third = list1(2)                 // 取得第三个元素，列表起始下标是0

for循环

从0循环到7（包括7）

for (i <- 0 to 7) { print(i + " ") }
println()

从0循环到7（不包括7）

for (i <- 0 until 7) { print(i + " ") }
println()

从0循环到10（包括10）步长2

for(i <- 0 to 10 by 2) { print(i + " ") }
println()

迭代器

val randomList = List(util.Random.nextInt(), util.Random.nextInt(), util.Random.nextInt(), util.Random.nextInt())
var listSum = 0
for (value <- randomList) {
  listSum += value
}
println("sum is " + listSum)

类

Scala中的类和Java中的类相似，都需要先创造出实例再使用，一个类的例子如下

class WrapCounter(counterBits: Int) {	//类的构造器需要一个传入的参数

  val max: Long = (1 << counterBits) - 1
  var counter = 0L							//类中一些变量的声明
    
  def inc(): Long = {				//类中的方法
    counter = counter + 1
    if (counter > max) {
        counter = 0
    }
    counter								//方法的返回值要写在最后一行
  }
  println(s"counter created with max value $max")	//这句println在类中，视为类初始化的一部分，每次实例化该类时会打印，可在debug时使用
}

类的实例化

val x = new WrapCounter(2)
x.inc()	//	两种调用类中方法的方式
x inc()

if(x.counter == x.max) {              // 没有声明成private的数据可以随意访问
    println("counter is about to wrap")
}

另外考虑以下代码，可以看出在参数声明和使用时可以通过指定参数名或者默认参数值，降低代码出错的可能性，并提高可读性

def myMethod(count: Int, wrap: Boolean, wrapValue: Int = 24): Unit = { ... }

myMethod(count = 10, wrap = false, wrapValue = 23)
myMethod(wrapValue = 23, wrap = false, count = 10)
myMethod(wrap = false, count = 10)
``