Scala（二）

01基础

1. 表达式（Expression）

• 表达式是可计算的语句。

1 + 1

• 我们可以使用println来输出表达式的结果。

println(1) // 1
println(1 + 1) // 2
println("Hello!") // Hello!
println("Hello," + " world!") // Hello, world!

值类型

• 与Java类似的Scala有Byte、Short、Int、Long、Float、Double、Char、Boolean，8种常用值类型。

• 与Java不同的是，Scala中 真·万物皆对象，所以没有所谓包装类，上面这八个值类型就是对象。

  

常量

• 我们可以使用val关键字来给表达式的结果命名。

val x = 1 + 1
println(x) // 2

• 对于结果，比如这里的x的命名，被称为常量。引用一个常量不会再次计算。

• 常量不能重新被赋值。

x = 3 // 编译失败

• 常量的类型可以被推断，或者我们也可以显示地声明类型，例如：

val x: Int = 1 + 1

• 需要注意的是，在标识符x的后面、类型声明Int的前面，还需要一个冒号:。

变量

• 除了可以重新赋值，变量和常量类似。我们可以使用var关键字来定义一个变量。

var y = 1 + 1
y = 3 // 可以编译通过，因为x使用var声明
println(y) // 3

• 和常量一样，你可以显示地声明类型：

var y: Int = 1 + 1

2. 代码块（Blocks）

我们可以组合几个表达式，并且用{}包围起来。我们称之为代码块（block）。

代码块中最后一个表达式的结果，也正是整个块的结果。

println({
  val x = 1 + 1
  x + 1
}) // 3

3. 方法（Method）

• 方法由def关键字定义。def后面跟着一个名字、参数列表、返回类型和方法体。

• 语法: def 方法名 ( 参数名 : 参数类型 ) : 返回值类型 = { 方法体 }

def add(x: Int, y: Int): Int ={
  x + y
}
println(add(1, 2)) // 3

• 或者没有参数列表。

def name(): String = System.getProperty("user.name")
println("Hello, " + name() + "!")

• 方法有多行表达式时，默认最后一行表达式的值作为方法的返回值。

def getSquareString(input: Double): String = {
  val square = input * input
  square.toString
}
println(getSquareString(2.5)) // 6.25

• Scala中也有return关键字，但绝大多数情况可以省略

4. 函数（Function）

• 函数是带有参数的表达式。

• 语法：( 参数名 : 参数类型 ) => { 函数体 }

• 我们可以定义一个匿名函数（即没有名字），来返回一个给定整数加一的结果。

(x: Int) => x + 1

• 我们也可以将函数赋值给一个变量，相当于给匿名函数起一个名字。

• 访问这个变量时，就是在调用这个函数。

• 这时这个变量的类型就是一个函数，在函数式编程范式中，函数是一等公民，与Int、String等对象一样，可以作为一个变量的类型。

val addOne = (x: Int) => x + 1
println(addOne(1)) // 2

• 函数可带有多个参数。

val add = (x: Int, y: Int) => x + y
println(add(1, 2)) // 3

• 或者不带参数。

val getTheNum = () => 23
println(getTheNum()) // 23

5. 类（class）

• 我们可以使用class关键字定义一个类，后面跟着它的名字。

class Student {
  def study(technology: String): Unit =
    println("get" + technology + "!")
}

• study方法的返回类型是Unit，代表没有什么有意义的需要返回。类似Java和C语言中的void。（不同点在于每个Scala表达式都必须有值，事实上有个Unit类型的单例值，写作()，它不携带任何信息）

• 我们可以使用new关键字创建一个类的实例。

val student = new Student()
student.study("Scala") // I will master the Scala!

6. 对象（object）

• 这里说的对象是使用object关键字定义的单个实例，我们可以把它看作它自己的类的单例。

object Amos {
    //说明：
    //1、当我们声明了var name :String时，在底层对应 private name'
    //2、同时会生成两个方法public name() --->类似于getter  public name_$eq() --->类似于 setter
 var name : String = "Amos"
 var salary : Double = 1.25
 def coding(job : Double) : Double = {
   salary += job
 }
}

• 你可以通过引用它的名字来访问一个对象。

val name = Amos.name //相当于调用Amos.name_$eq("Amos")
println(name) // Amos
val newSalary: Double = Amos.coding(5)
println(newSalary) // 6.25

7. 特质（trait）

• 特质是一个使用trait关键字声明的包含某些字段和方法的结构，类似于Java中的接口(interface)。特质允许多继承。

trait Person {
  def eat(food: String): Unit
}

• 特质也可以有默认的实现。

trait Person {
  def eat(food: String): Unit = {
    println("用碗吃" + food)
  }
}

• 我们可以使用extends关键字来继承特质，使用override关键字来覆盖默认的实现。

class NormalPerson extends Person
​
class GanfanPerson extends Person {
  override def eat(food: String): Unit = {
    println("用盆吃" + food)
  }
}
val normalPerson = new NormalPerson
normalPerson.eat("臊子面") // 用碗吃臊子面
val ganfanPerson = new GanfanPerson
ganfanPerson.eat("臊子面") // 用盆吃臊子面