本文的假設基礎是：你有一定的程式設計功底，並且已經知道你要使用Scala做什麼。最好對函數語言程式設計有所瞭解。如果你有指令碼語言的基礎例如Python，那麼一定會更快。

Scala Interpreter

和其他指令碼語言相通，Scala也有一個直譯器。

定義值

val msg="shitshit"

• 這不是一個變數，而是一個值。
• 沒有必要為它去定義型別，它被自動識別為java.lang.String
• 你不能修改msg的值。（python中也有類似的特性，但是python沒有val關鍵字）

定義變數

var h="hhhhh"
h="fffff"
 

• 這是一個變數，可以改變值
• 它的型別依然是java.lang.String

定義方法

def max(x:Int,y:Int): Int=if(x<y) y else x

也可以不宣告返回型別：

def max2(x: Int, y: Int) = if (x < y) y else x

可以使用括號括起來：

scala> def max3(x: Int, y: Int) = { if (x < y) y else x }

呼叫方法沒有什麼特殊之處：

max(1,2)

Scala指令碼

在系統終端中

scala  my
 
.scala

scala可以方便地呼叫外部引數：

#打印出第一個引數
println(arg(0))

linux下的一點奇技淫巧：

#!/bin/sh
exec scala $0 [email protected]
!#
// Say hello to the first argument
println("Hello, " + args(0) + "!")

./helloarg globe

while和if

var i = 0
while (i < args.length) {
  if (i != 0)
    print(" ")
  print(args
 
(i))
  i += 1
}
println()

迭代器：foreach 和 for

foreach

args.foreach(arg=>println(arg))

for

for(arg<-args)
    println(arg)

陣列

這是一個比較奇怪的定義方式：

val greetStrings = new Array[String](3)

greetStrings(0) = "Hello"
greetStrings(1) = ", "
greetStrings(2) = "world!\n"

for (i <- 0 to 2)
  print(greetStrings(i))

其中

greetStrings(0) = "Hello" 
會被偷偷換成
greetStrings.update(0, "Hello")

list和tuple

list的定義和串聯

val oneTwoThree = List(1, 2, 3)
val fourfive=List(4,5)
val s=oneTwoThree:::fourfive
和元素串聯：
val m=oneTwoThree::1

tuple
方便的結構體

val pair =(100,"shit")
println(pair._1)
println(pair._2)

Set和Maps

HashSet

import scala.collection.mutable.HashSet

val jetSet = new HashSet[String]
jetSet += "Lear"
jetSet += ("Boeing", "Airbus")
println(jetSet.contains("Cessna"))

HashMaps

import scala.collection.mutable.HashMap

val treasureMap = new HashMap[Int, String]
treasureMap += 1 -> "Go to island."
treasureMap += 2 -> "Find big X on ground."
treasureMap += 3 -> "Dig."
println(treasureMap(2))

Class

// In greetSimply.scala

class SimpleGreeter {
  val greeting = "Hello, world!"
  def greet() = println(greeting)
}

val g = new SimpleGreeter
g.greet()

// In greetFancily.scala

class FancyGreeter(greeting: String) {
  def greet() = println(greeting)
}

val g = new FancyGreeter("Salutations, world")
g.greet

這個類看起來有點奇怪，定義也是建構函式。

單例模式

// In WorldlyGreeter.scala

// The WorldlyGreeter class
class WorldlyGreeter(greeting: String) {
  def greet() = {
    val worldlyGreeting = WorldlyGreeter.worldify(greeting)
    println(worldlyGreeting)
  }
}

// The WorldlyGreeter companion object
object WorldlyGreeter {
  def worldify(s: String) = s + ", world!"
}

因為Scala下是面向物件的，所以其入口函式也在類裡：

// In WorldlyApp.scala
// A singleton object with a main method that allows
// this singleton object to be run as an application
object WorldlyApp {
  def main(args: Array[String]) {
    val wg = new WorldlyGreeter("Hello")
    wg.greet()
  }
}

traits

traits類似於java中的interface

trait Friendly {
  def greet() = "Hi"
}

連關鍵字都沒有改：extentds、override

class Dog extends Friendly {
  override def greet() = "Woof"
}