Scala 简介
Scala 是 Scalable Language 的简写，是一门多范式的编程语言
联邦理工学院洛桑（EPFL）的Martin Odersky于2001年基于Funnel的工作开始设计Scala。
Funnel是把函数式编程思想和Petri网相结合的一种编程语言。
Odersky先前的工作是Generic Java和javac（Sun Java编译器）。Java平台的Scala于2003年底/2004年初发布。.NET平台的Scala发布于2004年6月。该语言第二个版本，v2.0，发布于2006年3月。
截至2009年9月，最新版本是版本2.7.6 。Scala 2.8预计的特性包括重写的Scala类库（Scala collections library）、方法的命名参数和默认参数、包对象（package object），以及Continuation。
2009年4月，Twitter宣布他们已经把大部分后端程序从Ruby迁移到Scala，其余部分也打算要迁移。此外， Wattzon已经公开宣称，其整个平台都已经是基于Scala基础设施编写的。
Scala 特性
面向对象特性
Scala是一种纯面向对象的语言，每个值都是对象。对象的数据类型以及行为由类和特质描述。
类抽象机制的扩展有两种途径：一种途径是子类继承，另一种途径是灵活的混入机制。这两种途径能避免多重继承的种种问题。
函数式编程
Scala也是一种函数式语言，其函数也能当成值来使用。Scala提供了轻量级的语法用以定义匿名函数，支持高阶函数，允许嵌套多层函数，并支持柯里化。Scala的case class及其内置的模式匹配相当于函数式编程语言中常用的代数类型。
更进一步，程序员可以利用Scala的模式匹配，编写类似正则表达式的代码处理XML数据。
静态类型
Scala具备类型系统，通过编译时检查，保证代码的安全性和一致性。类型系统具体支持以下特性：
泛型类
协变和逆变
标注
类型参数的上下限约束
把类别和抽象类型作为对象成员
复合类型
引用自己时显式指定类型
视图
多态方法
扩展性
Scala的设计秉承一项事实，即在实践中，某个领域特定的应用程序开发往往需要特定于该领域的语言扩展。Scala提供了许多独特的语言机制，可以以库的形式轻易无缝添加新的语言结构：
任何方法可用作前缀或后缀操作符
可以根据预期类型自动构造闭包。
并发性
Scala使用Actor作为其并发模型，Actor是类似线程的实体，通过邮箱发收消息。Actor可以复用线程，因此可以在程序中可以使用数百万个Actor,而线程只能创建数千个。在2.10之后的版本中，使用Akka作为其默认Actor实现。
入门
似乎一切语言的学习，都从“Hello, World!”开始，这次也不能免俗，先来第一个程序：
编程工具推荐使用intelliJ IDEA
object HelloWorld {
def main(args: Array[String]): Unit = {
println("Hello, world!")
}
} def main(args: Array[String]) - Scala程序从main()方法开始处理，这是每一个Scala程序的强制程序入口部分。
我的理解是主函数，基本每个费脚本语言程序都有。
Scala 基础语法
如果你之前是一名 Java 程序员，并了解 Java 语言的基础知识，那么你能很快学会 Scala 的基础语法。
Scala 与 Java 的最大区别是：Scala 语句末尾的分号 ; 是可选的。
我们可以认为 Scala 程序是对象的集合，通过调用彼此的方法来实现消息传递。接下来我们来理解下，类，对象，方法，实例变量的概念：
对象 - 对象有属性和行为。例如：一只狗的状属性有：颜色，名字，行为有：叫、跑、吃等。对象是一个类的实例。
类 - 类是对象的抽象，而对象是类的具体实例。
方法 - 方法描述的基本的行为，一个类可以包含多个方法。
字段 - 每个对象都有它唯一的实例变量集合，即字段。对象的属性通过给字段赋值来创建。
scale基本跟java类似，一些使用上面更灵活更简洁，方法和类的定义基本和java一样,省去了理解上的不少麻烦。
输出：scale 的输出没有java那么长一串，只需要很简单的println()
就可以输出你想要的数据：
object HelloWorld {
/* 这是我的第一个 Scala 程序
* 以下程序将输出'Hello World!'
*/
def main(args: Array[String]) {
println("Hello, world!") // 输出 Hello World
var s = myＡdd(7,8) //调用方法函数
}
#方法定义
def myＡdd(int2: Int ,int1: Int): Int={
//Int 是返回数据的类型
var result = int2+int1
return result
}
}创建一个person类：
/**
* Created by zhuan on 16-10-8.
*/
class Ｐerson(x:Int,y:Int) {
var age:Int = x;
var salary:Int = y;
def judge(){
if(age<salary/３00){
println("you are a successful man!")
}else{
println("you are a lose man...")
}
}
}根据上述Person类New一个Person对象：
var NewMan = new Ｐerson(35,7500);
初学者可能对var 和val 搞不清，作用差不多，好像都能用，其实不然：
val 值不可变(等同于java里的 final )
而var 是可变，由于不是本文重点，更多细节区别不在赘述。
导包上的区别：一次可以同一目录下的多个包
import java.awt.{Color, Font}
// 重命名成员
import java.util.{HashMap => JavaHashMap}
// 隐藏成员
import java.util.{HashMap => _, _} // 引入了util包的所有成员，但是HashMap被隐藏了Scale数据类型：
变量的声明：
var myVar : String = "Foo"
var myVar : String = "Too"
var VariableName : DataType [= Initial Value]
val VariableName : DataType [= Initial Value]
//不声明初始值
var myVar :Int;
val myVal :String;函数声明：
def functionName ([参数列表]) : [return type]
def functionName ([参数列表]) : [return type] = {
function body
return [expr]
}Scala 访问修饰符
Scala 访问修饰符基本和Java的一样，分别有：private，protected，public。
如果没有指定访问修饰符符，默认情况下，Scala对象的访问级别都是 public。
Scala 中的 private 限定符，比 Java 更严格，在嵌套类情况下，外层类甚至不能访问被嵌套类的私有成员。
有特色的闭包函数，感觉有点像python里面的lambda函数：
object Test {
def main(args: Array[String]) {
println( "muliplier(1) value = " + multiplier(1) )
println( "muliplier(2) value = " + multiplier(2) )
}
var factor = 3
val multiplier = (i:Int) => i * factor
} 数据结构
数组：
var z:Array[String] = new Array[String](3)
//或
var z = new Array[String](3)
var z = Array("Runoob", "Baidu", "Google")多维数组：
import Array._
object Test {
def main(args: Array[String]) {
var myMatrix = ofDim[Int](3,3)
// 创建矩阵
for (i <- 0 to 2) {
for ( j <- 0 to 2) {
myMatrix(i)(j) = j;
}
}
// 打印二维阵列
for (i <- 0 to 2) {
for ( j <- 0 to 2) {
print(" " + myMatrix(i)(j));
}
println();
}
}
}这里顺便提一下，scale特有的for 循环：
for (i <- 0 to 2) {
for ( j <- 0 to 2) {
print(" " + myMatrix(i)(j));
}
println();
}
}scale使用<- 这个符号给i 赋值，这个赋值符号跟Ｒ语言的<-是一样的，根据Ｒ来理解似乎是两者并不是完全意义上的相等，而是一种类似Ｃ语言一样的指针指代关系，似乎这样的符号比＝更贴切。
for (i <- 0 to 2) 等价于：for (int i=0;i<=2;i++)
list
// 字符串列表
val site: List[String] = List("Runoob", "Google", "Baidu")
// 整型列表
val nums: List[Int] = List(1, 2, 3, 4)
// 空列表
val empty: List[Nothing] = List()
// 二维列表
val dim: List[List[Int]] =
List(
List(1, 0, 0),
List(0, 1, 0),
List(0, 0, 1)
)
// 字符串列表
val site = "Runoob" :: ("Google" :: ("Baidu" :: Nil))
// 整型列表
val nums = 1 :: (2 :: (3 :: (4 :: Nil)))
// 空列表
val empty = Nil
// 二维列表
val dim = (1 :: (0 :: (0 :: Nil))) ::
(0 :: (1 :: (0 :: Nil))) ::
(0 :: (0 :: (1 :: Nil))) :: NilScala Iterator（迭代器）
object Test {
def main(args: Array[String]) {
val it = Iterator("Baidu", "Google", "Runoob", "Taobao")
while (it.hasNext){
println(it.next())
}
}
}