数据类型
Byte	8 位有符号值，范围：-128~127
Short	16 位有符号值，范围：-32768~32767
Int	    32 位有符号值，范围：-2147483648~2147483647
Long	64 位有符号值，范围：-9223372036854775808~9223372036854775807
Float	32 位 IEEE754 单精度浮点数
Double	64 位 IEEE754 双精度浮点数
Char	16 位无符号 Unicode 字符，范围：U+0000~U+FFFF
String	字符串
Boolean	布尔值 true / false
Unit	表示没有值
Null	空或空引用
Nothing	每一个其他类型的子类型，包括无值
Any	    任何类型的超类型，任何 object 都是 Any 类型
AnyRef	任何引用类型的超类型

var  变量
val  不可变量

函数定义 def
def functionName ([list of parameters]) : [return type] = {
   function body
   return [expr]
}

def addOne(m: Int): Int = {
    return m + 1
}
def addOne(): Int = 1 + 1

函数不带参数，调用时可不写括号
函数体中的语句只有一个语句，可省略大括号

def add(x: Int, y: Int) :Int = {
    return x + y
}
var add1 = add(1, _:Int)
var add2 = add1(2)

// 单词首字母大写
def capitalizeAll(args: String*) = {
    args.map { arg =>arg.capitalize}
}
var str = capitalizeAll("hello", "scala")
println(str)


无参构造函数

class Calculator {
    val brand: String = "ibm"
    def add(m: Int, n: Int): Int = m + n
}
val calc = new Calculator
println(calc.brand)
println(calc.add(1, 2))

带一个参数的构造函数
class Calculator(brand: String) {
    val color: String = if (brand == "ibm") {
        "blue"
    } else if (brand == "alibaba") {
        "orange"
    } else {
        "white"
    }
    // 实例方法
    def add(m: Int, n: Int): Int = m + n
}

val calc = new Calculator("ibm")
calc.color


class CalculatorA(brand: String) extends Calculator(brand) {
    def sum(a: Double, b: Double) = a + b
}

class CalculatorB(brand: String) extends CalculatorA(brand) {
  def sum(a: Double, b: Double,c:Double): Double =  a + b + c
}

val calca = new  CalculatorA("ibm")
calca.sum(1,2)

val calcb = new  CalculatorB("ibm")
calcb.sum(1,2)
calcb.sum(1,2,3)

抽象类

abstract class Shape {
    def getArea():Double 
}

// 子类
class Circle(r: Double) extends Shape {
    def getArea():Double = { r * r * 3.14 }
}
val c = new Circle(1)
c.getArea()
c.getArea

特质（Traits）


trait Equal {
  def isEqual(x: Any): Boolean
  def isNotEqual(x: Any): Boolean = !isEqual(x)
}

class Point(xc: Int, yc: Int) extends Equal {
  var x: Int = xc
  var y: Int = yc
  def isEqual(obj: Any) =
    obj.isInstanceOf[Point] &&
    obj.asInstanceOf[Point].x == x
}

object Test {
   def main(args: Array[String]) {
      val p1 = new Point(2, 3)
      val p2 = new Point(2, 4)
      val p3 = new Point(3, 3)

      println(p1.isNotEqual(p2))
      println(p1.isNotEqual(p3))
      println(p1.isNotEqual(2))
   }
}

Test.main(null)
 

集合

列表（List） 集合（Set） 映射（Map） 选项（Option）元组（Tuple）

val list1 = List(1, 2, 3)
val set1 = Set(1, 3, 5)
val map1 = Map("one" -> 1, "two" -> 2)
val tuple1 = (2, "two")
val opt1:Option[Int] = Some(5)