Scala语言是一种面向对象语言，结合了命令式（imperative）和函数式（functional）编程风格，其设计理念是创造一种更好地支持组件的语言。
特性
-
多范式（Multi-Paradigm）编程语言，类似Java、C#；
-
继承面向对象编程和函数式编程的特性；
-
面向对象：[1]. 子类继承，[2]. 混入(Mixin)机制；
-
函数式：支持高阶函数、嵌套函数，模式匹配，支持柯里化(Currying)；
-
类型推断（Type Inference）：根据函数体中的具体内容推断方法的返回值类型
-
-
更高层的并发模型，可伸缩；
-
静态类型，编译时检查；
-
允许与Java互操作（将来会支持与.Net互操作）；
与Java对比
-
如果用作服务器端开发，Scala的简洁、灵活性是Java无法比拟的；
-
如果是企业级应用开发、Web开发，Java的强大是Scala无法匹敌的；
基础语法
表达式（Expressions）
表达式是可计算的语句。您可以使用println输出表达式的结果。
println(1) // 1
println(1 + 1) // 2
println("Hello!") // Hello!
println("Hello," + " world!") // Hello, world!
值（Values）
您可以使用val关键字命名表达式的结果。
val x = 1 + 1
println(x) // 2
命名结果（例如x）称为值。引用值不会重新计算它。值无法被重新分配。
val x = 1 + 1
x = 3 // This does not compile.
可以推断出值的类型，但您也可以显式声明类型，如下所示：
val x: Int = 1 + 1
注意类型声明Int如何在标识符x之后出现，你还需要一个“:”
变量（Variables）
变量就像值，除了你可以重新赋值。您可以使用var关键字定义变量。
var x = 1 + 1
x = 3 // This compiles because "x" is declared with the "var" keyword.
println(x * x) // 9
与值一样，您可以根据需要明确说明类型：
var x: Int = 1 + 1
块（Blocks）
您可以通过用{}包围表达式来组合表达式。我们称之为块。块中最后一个表达式的结果也是整个块的结果。
println({
val x = 1 + 1
x + 1
}) // 3
函数（Functions）
函数是带参数的表达式。
您可以定义一个返回给定整数加一的匿名函数（即无名称）：
(x: Int) => x + 1
在=>的左边是参数列表。右边是涉及参数的表达式。
您也可以命名函数。
val addOne = (x: Int) => x + 1
println(addOne(1)) // 2
函数可能需要多个参数。
val add = (x: Int, y: Int) => x + y
println(add(1, 2)) // 3
或者它不需要参数。
val getTheAnswer = () => 42
println(getTheAnswer()) // 42
方法（Methods）
方法的外观和行为与函数非常相似，但它们之间存在一些关键差异。
方法使用def关键字定义。 def后跟名称，参数列表，返回类型和正文。
def add(x: Int, y: Int): Int = x + y
println(add(1, 2)) // 3
注意如何在参数列表和冒号之后声明返回类型：Int。
方法可以采用多个参数列表。
def addThenMultiply(x: Int, y: Int)(multiplier: Int): Int = (x + y) * multiplier
println(addThenMultiply(1, 2)(3)) // 9
或者根本没有参数列表。
def name: String = System.getProperty("user.name")
println("Hello, " + name + "!")
还有一些其他差异，但就目前而言，您可以将它们视为与函数类似的东西。
方法也可以有多行表达式。
def getSquareString(input: Double): String = {
val square = input * input
square.toString
}
正文中的最后一个表达式是方法的返回值。 （Scala确实有一个return关键字，但它很少使用。）
关于方法（Method）和函数（Function）
函数是一等公民，使用val语句可以定义函数，def语句定义方法；
函数是一个对象，继承自FuctionN，函数对象有curried,equals,isInstanceOf,toString等方法，而方法不具有；
函数是一个值，可以给val变量赋值，方法不是值、也不可以给val变量赋值；
通过将方法转化为函数的方式 method _ 或 method(_) 实现给val变量赋值；
若 method 有重载的情况，方法转化为函数时必须指定参数和返回值的类型；
某些情况下，编译器可以根据上下文自动将方法转换为函数；
无参数的方法 method 没有参数列表（调用：method），无参数的函数 function 有空列表（调用：function()）；
方法可以使用参数序列，转换为函数后，必须用 Seq 包装参数序列；
方法支持默认参数，函数不支持、会忽略之；
类（Classes）
您可以使用class关键字定义类，后跟其名称和构造函数参数。
class Greeter(prefix: String, suffix: String) {
def greet(name: String): Unit =
println(prefix + name + suffix)
}
方法greet的返回类型是Unit，它表示返回没有任何意义。它与Java和C中的void类似地使用。（不同之处在于，因为每个Scala表达式必须具有某个值，实际上存在Unit类型的单例值，write（）。它不携带任何信息。）
您可以使用new关键字创建类的实例。
val greeter = new Greeter("Hello, ", "!")
greeter.greet("Scala developer") // Hello, Scala developer!
样本类（Case Classes）
Scala有一种特殊类型的类，称为样本类。默认情况下，样本类是不可变的，并按值进行比较。您可以使用“case class”关键字定义案例类。
case class Point(x: Int, y: Int)
您可以在没有new关键字的情况下实例化样本类。
val point = Point(1, 2)
val anotherPoint = Point(1, 2)
val yetAnotherPoint = Point(2, 2)
并且它们按值进行比较。
if (point == anotherPoint) {
println(point + " and " + anotherPoint + " are the same.")
} else {
println(point + " and " + anotherPoint + " are different.")
}
// Point(1,2) and Point(1,2) are the same.
if (point == yetAnotherPoint) {
println(point + " and " + yetAnotherPoint + " are the same.")
} else {
println(point + " and " + yetAnotherPoint + " are different.")
}
// Point(1,2) and Point(2,2) are different.
对象（Objects）
对象是它们自己定义的单个实例。你可以把它们想象成自己班级的单身人士。
您可以使用object关键字定义对象。
object IdFactory {
private var counter = 0
def create(): Int = {
counter += 1
counter
}
}
您可以通过引用其名称来访问该对象。
val newId: Int = IdFactory.create()
println(newId) // 1
val newerId: Int = IdFactory.create()
println(newerId) // 2
抽象类
你可以定义一个抽象类，它定义了一些方法但没有实现它们。取而代之是由扩展抽象类的子类定义这些方法。你不能创建抽象类的实例。
abstract class Shape {
def getArea():Int // subclass should define this
}
class Circle(r: Int) extends Shape {
def getArea():Int = { r * r * 3 }
}
val s = new Shape //error: class Shape is abstract; cannot be instantiated
val c = new Circle(2)
特质（Traits）
特质是包含某些字段和方法的类型。可以组合多种特质。
您可以使用trait关键字定义特质。
trait Greeter {
def greet(name: String): Unit
}
特质也可以有默认实现。
trait Greeter {
def greet(name: String): Unit =
println("Hello, " + name + "!")
}
您可以使用extends关键字扩展traits并使用override关键字覆盖实现。
class DefaultGreeter extends Greeter
class CustomizableGreeter(prefix: String, postfix: String) extends Greeter {
override def greet(name: String): Unit = {
println(prefix + name + postfix)
}
}
val greeter = new DefaultGreeter()
greeter.greet("Scala developer") // Hello, Scala developer!
val customGreeter = new CustomizableGreeter("How are you, ", "?")
customGreeter.greet("Scala developer") // How are you, Scala developer?
在这里，DefaultGreeter只扩展了一个特质，但它可以扩展多个特质。
什么时候应该使用特质而不是抽象类？
如果你想定义一个类似接口的类型，你可能会在特质和抽象类之间难以取舍。这两种形式都可以让你定义一个类型的一些行为，并要求继承者定义一些其他行为。一些经验法则：
-
优先使用特质。一个类扩展多个特质是很方便的，但却只能扩展一个抽象类。
-
如果你需要构造函数参数，使用抽象类。因为抽象类可以定义带参数的构造函数，而特质不行。例如，你不能说trait t(i: Int) {}，参数i是非法的。
Main方法
Main方法是程序的切入点。 Java虚拟机需要将main方法命名为main，并使用一个参数，即一个字符串数组。
使用对象，您可以按如下方式定义main方法：
object Main {
def main(args: Array[String]): Unit =
println("Hello, Scala developer!")
}
本文主要翻译自Basics|Scala Documentation