Scala（二）Scala基础语法小汇总

认识Scala

Scala 是一门多范式（multi-paradigm）的编程语言，设计初衷是要集成面向对象编程和函数式编程的各种特性。

Scala 运行在Java虚拟机上，并兼容现有的Java程序。

Scala 源代码被编译成Java字节码，所以它可以运行于JVM之上，并可以调用现有的Java类库。

Scala特性

面向对象特性

Scala是一种纯面向对象的语言，每个值都是对象。对象的数据类型以及行为由类和特质描述。

类抽象机制的扩展有两种途径：一种途径是子类继承，另一种途径是灵活的混入机制。这两种途径能避免多重继承的种种问题。

函数式编程

Scala也是一种函数式语言，其函数也能当成值来使用。Scala提供了轻量级的语法用以定义匿名函数，支持高阶函数，允许嵌套多层函数，并支持柯里化。Scala的case class及其内置的模式匹配相当于函数式编程语言中常用的代数类型。

更进一步，程序员可以利用Scala的模式匹配，编写类似正则表达式的代码处理XML数据。

静态类型

Scala具备类型系统，通过编译时检查，保证代码的安全性和一致性。类型系统具体支持以下特性：

• 泛型类
• 协变和逆变
• 标注
• 类型参数的上下限约束
• 把类别和抽象类型作为对象成员
• 复合类型
• 引用自己时显式指定类型
• 视图
• 多态方法

扩展性

Scala的设计秉承一项事实，即在实践中，某个领域特定的应用程序开发往往需要特定于该领域的语言扩展。Scala提供了许多独特的语言机制，可以以库的形式轻易无缝添加新的语言结构：

任何方法可用作前缀或后缀操作符
可以根据预期类型自动构造闭包。

并发性

Scala使用Actor作为其并发模型，Actor是类似线程的实体，通过邮箱发收消息。Actor可以复用线程，因此可以在程序中可以使用数百万个Actor,而线程只能创建数千个。在2.10之后的版本中，使用Akka作为其默认Actor实现。

Scala语法

基本语法

Scala 基本语法需要注意以下几点：

• 区分大小写 - Scala是大小写敏感的，这意味着标识Hello 和 hello在Scala中会有不同的含义。

• 类名 - 对于所有的类名的第一个字母要大写。
  如果需要使用几个单词来构成一个类的名称，每个单词的第一个字母要大写。
  示例：class MyFirstScalaClass

• 方法名称 - 所有的方法名称的第一个字母用小写。
  如果若干单词被用于构成方法的名称，则每个单词的第一个字母应大写。
  示例：def myMethodName()

• 程序文件名 - 程序文件的名称应该与对象名称完全匹配(新版本不需要了，但建议保留这种习惯)。
  保存文件时，应该保存它使用的对象名称（记住Scala是区分大小写），并追加".scala"为文件扩展名。 （如果文件名和对象名称不匹配，程序将无法编译）。

• 示例: 假设"HelloWorld"是对象的名称。那么该文件应保存为’HelloWorld.scala"

• def main(args: Array[String]) - Scala程序从main()方法开始处理，这是每一个Scala程序的强制程序入口部分。

基础语法

声明变量

• var：变量声明，程序运行过程中会发生改变的量
• val：常量声明，定义后不会改变的量，相当于Java中定义的final量

声明变量的语法：

var x = 1 //声明变量时候没有定义变量类型，程序运行时会根据赋值的内容动态的定义变量类型

var x:int = 1 //手动定义变量类型

var x, y = 100 // 多个变量的声明，x, y都声明为100

var arr = Array[Int](1,2,3)// 声明一个数组，包含1，2，3三个元素
var arr1 = new Array[Int](3)// 声明一个长度为3数组，里面包含的三个元素，是int的默认值（0）

val x = List(1,2,3,4) // 声明整型 List

val x = Set(1,3,5,7) //声明一个set

val x = (10, ->“scala”) // 或者 val x = (10, “scala”)，声明一个元组

val x = Map(“java” -> 1, “scala” -> 2) // 或者 val x = Map((“java” , 1),( “scala” , 2))，声明一个map

Scala 方法与函数

Scala 中的方法（method）跟 Java 的类似，方法是组成类的一部分。

Scala 中的函数（function）则是一个完整的对象，Scala 中的函数其实就是继承了 Trait 的类的对象。

Scala 中可以使用 val 、var接受定义的函数对象，def 语句定义方法。

• Scala 方法声明格式如下：

def functionName ([参数列表]) : [return type] = {
//方法主体
//return [expr]
//scala中return关键字可省略，如果不写默认最后一行是返回的对象
}
//如果你不写等于号和方法主体，那么方法会被隐式声明为抽象(abstract)，包含它的类型也是一个抽象类型。

列如：

def addInt( a:Int, b:Int ) : Int = {
      var sum:Int = 0
      sum = a + b
      return sum
}
//如果方法没有返回值，可以返回为 Unit，这个类似于 Java 的 void, 
def print( ) : Unit = {
      println("Hello, Scala!")
}

• Scala 函数声明格式如下：

val f = ([参数列表]) => {
//方法主体
}

函数可以作为参数传递，而方法不行：

object TestMain{
  
  //定义一个方法，方法 m1 参数要求是一个函数，函数的参数必须是两个Int类型，返回值类型也是Int类型
  def m1(f:(Int,Int) => Int) : Int = {
    f(2,6)
  }
  //定义一个函数f1,参数是两个Int类型，返回值是一个Int类型
  val f1 = (x:Int,y:Int) => x + y // 也可以使用简写：val f1 =  (_:Int)  + (_:Int )，第一个_表示第一个参数，一次类推
  
  def main(args: Array[String]): Unit = {
    //调用m1方法，并传入f1函数
    val r1 = m1(f1)
    println(r1)//运行结果为8
  }
}

Scala if 表达式

scala if表达式与java的if表达式的格式基本相同，不同点在于scala的灵活性，下面代码就可以看出区别：

  val flag = true
  //条件判断并赋值，
  val result=
     if(flag) 100
     else "一百"

while循环与for 表达式

• while循环

while( [boolean表达式]) {
    //循环体
}

• do-while循环

do {
//循环体
} while ([boolean表达式])

• for表达式
  Scala的for表达式与java很相似，但是更加灵活，操作性更丰富，基本格式如下：

for( var x <- [范围]){
   //循环体
}

循环1到10：

for( a <- 1 to 10){
         println( "Value of a: " + a );
}

使用until关键字，循环1到9，不包含10：

for( a <- 1 until 10){
         println( "Value of a: " + a );
}

多区间循环：

for( a <- 1 to 3; b <- 1 to 3){
      println( "[a" + a +"],[b" + b + "]");
}
//输出结果：
[a1],[b1]
[a1],[b2]
[a1],[b3]
[a2],[b1]
[a2],[b2]
[a2],[b3]
[a3],[b1]
[a3],[b2]
[a3],[b3]

循环对象：

val arr = Array[Int](1,2,3)
for(x <- arr) {
      println(x)
}

使用yield关键字保存循环对象：

val arr = Array[Int](1,2,3)
val result = for(x <- arr) yield "我是" + x
for (r <- result) {
      println(r)
}
//输出
我是1
我是2
我是3

Scala “_”下划线的用法

• 用于默认初始化

  var num :Int =_
  var str :String=_
  def main(args: Array[String]): Unit = {
    println(num)
    println(str)
  }
\\输出
0
null

• 导入包
  Java中导包：import math.*，Scala中是import math._，这里的_相当于*

• 集合中使用（最典型，最常用）

object Sample {
   def main (args: Array[String]){
    val newArry= (1 to 10).map(_*2)
    println(newArry)
   }
}

这里的下划线代表了集合中的“某（this）”一个元素。这个用法很常见，在foreach等语句中也可以使用。

• 模式匹配

object Sample {
   def main (args: Array[String]){
     val value="a"
  val result=  value match{
       case "a" => 1
       case "b" => 2
       case _ =>"result"
       //在这里的下划线相当于“others”的意思，就像Java  switch语句中的“default”
     }
     println(result)
   }
}

object Sample {
  def main (args: Array[String]){
    val value=Some("a")
    val result=  value match{
      case Some(_) => 1
      //被Some“包”起来的，说明Some里面是有值的，而不是None
      case _ =>"result"
    }
    println(result)
  }

• 函数中使用

object Sample {
   def main (args: Array[String]){
    val set=setFunction(3.0,_:Double)
     println(set(7.1))
   }
  def setFunction(parm1:Double,parm2:Double): Double = parm1+parm2
}

这是Scala特有的“偏函数”用法。

Scala还有很多奇怪的语法，也正是因为这些古怪的语法让Scala这门语言更加精简、更加有魅力，这篇文章主要列举一些常用的语法入门，更多的语法还需要慢慢地去学习积累。大家一起共勉