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

淡淡的烟草味﹌ 2022-04-03 05:29 357阅读 0赞

# 认识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这门语言更加精简、更加有魅力，这篇文章主要列举一些常用的语法入门，更多的语法还需要慢慢地去学习积累。大家一起共勉 ###