Scala基础知识

谁适合阅读本教程？

本教程适合想从零开始学习 Scala 编程语言的开发人员,强烈建议你有一定的 JAVA 基础，因为 Scala 从 JAVA 演化而来

学习任务

1、解释器

2、基础语法

3、函数

4、条件与循环

2.1、Scala解释器

2.1.1、 交互模式

顾名思义就是在命令行调用scala的基础环境，我们在第一篇演示的命令行输出Hello,World!即是。当然Scala在交互模式下能够做很多的事情。在这里我们只做简单的输出演示。

CTRL+C退出交互模式

2.1.2、脚本模式

类似于我们在命令行通过 <font color=#7A67EE>java *.java执行</font>一样，我们通过记事本创建一个文件HelloWorld.scala,存储在指定目录，我存储在了/Users/sunliangliang/Desktop/temp这个目录下，代码如下

object HelloWorld {
   /* 这是我的第一个Scala项目，
    * 输出"Hello，Scala！"
   */
   def main(args: Array[String]) {
      println("Hello, Scala!")
   }
}

在命令行执行 scala /Users/sunliangliang/Desktop/temp/HelloWorld.scala,看到如下输出结果

2.2、基础语法

2.2.1、基础内容普及

• 区分大小写：大小写敏感，即Scala和scala在程序中含义不同
• 类名：首字母大写，驼峰式
• 方法名：首字母小写，驼峰
• 文件名：文件名要和对象/类名匹配
• 包名：全小写
• 常量名：全大写
• 行结尾: 行结尾的”;”可省略
• 空格与缩进：运算符前后保留一个空格如：

  def main(args: Array[String]): Unit = {
    print("Hello world")
  }

语法规范基本和java一样，其他可参考java相关规范。

2.2.2、变量与常量

1、常量的声明:

val 常量名 ：数据类型 = 值 scala采用数据类型在后面的方式

val str : String = "Scala"

2、变量的声明：

var 变量名 : 数据类型 = 值 ，如下图

var number : Int = 2

如上面，注意运算符前后空格，行结尾分号可省略，数据类型Int和String都是大写，这是不同于java的一些地方

2.2.3、数据类型

<font color = red>scala所有的数据类型都是对象，没有java的原生基本类型</font>

1、常用数据类型

Scala和java的数据类型基本一致

2、其他常用类型

如下图为Scala数据结构的结构图

2.2.4、关键字与标识符

1、关键字

Scala有39个关键字，有一部分和java重合

• package, import, class, object, trait, extends, with, type, forSome
• private, protected, abstract, sealed, final, implicit, lazy, override
• try, catch, finally, throw
• if, else, match, case, do, while, for, return, yield
• def, val, var
• this, super
• new
• true, false, null

如下图所示是java和Scala的重合的地方

2、标识符

• 1、字母标识符

以字母或者下划线开头，之后可以跟字母数字或者下划线。不能使用$，尽管可以编译通过

Scala遵循java的驼峰式标识符，因此尽管下划线是合法的，但是为了同java保持一致，尽量不要使用

• 2、操作标识符

由一个或多个操作字符组成，同java或其他语言，如
+ ++ ::: <?> :->等

2.3、方法与函数

函数和方法类似，这里的方法和java中的基本一致，两者主要区别在于在Scala中函数是一个值，可以赋值给一个val变量，而方法不可以。

2.3.1、方法的定义与调用

方法的定义

def 方法名(参数列表): 返回类型 = {方法体},如：

  def add(x:Int,y:Int): Int = {
    x+y
  }

在scala中方法体的最后一行作为函数的返回值，不需要写return

方法的调用

方法名(参数)，同java，如下图

object Helloworld {

  def main(args: Array[String]): Unit = {
    val result = add(2,7)//调用函数
    println(result)
  }

  /**
    * 方法的定义与声明
    * @param x
    * @param y
    * @return
    */
  def add(x:Int,y:Int): Int = {
    x + y
  }
}

2.3.2、函数的定义与调用

函数的定义

val multiply = (x:Int,y:Int) => x*y;//定义一个函数，乘法

函数的调用

println(multiply(2,5)) //函数的调用

方法和函数之间也可以相互转换，如下

• 方法转函数

  val plus = add _

神奇的下划线将方法转化为了函数，注意==上面的代码需要写在方法体外，作为全局的变量==

2.3.3、主函数

同java的main函数，scala中main函数同样作为函数的入口。在scala中，main函数必须定义在object中（Java中，main函数必须是class中的static方法），有两种方式，第一种参考上面Helloworld代码，另一种如下

object FastScalaApp extends App {
  override def main(args: Array[String]): Unit = {
    print("FastScalaApp started!!!")
  }
}

这种类似于springboot中的入口类

2.4、条件与循环

2.4.1、条件

1、条件：if->else，如下图

  /**
    * 条件语句
    * @param x
    */
  def condition(x:Int): Unit ={

    if (x>10){
      print("x 比 10 大")
    } else if (x == 10){
      print("x 和 10 相等")
    }else{
      print("x 比 10 小")
    }
  }

此处，else if 和 else也可省略。
一个if语句可以跟着一个可选的else if … else

注意事项

• 1、if后面可以有0或者多个else语句，但是整个语句的最后，即前面条件都匹配不到才会执行
• 2、if后可以有0或者多个else if语句，else if语句在if 和 else语句之间
• 3、一个else if 匹配成功后续的else if 和 else就都不会执行。

2、嵌套if

    if(x > 5){
      if (x<10){
        print("x 在5 和10 之间")
      }
    }
    

2.4.2、循环

scala的循环类型和java一样，包含以下三类

循环控制语句

while循环

  /**
    * while循环
    */
  def whileLoop(): Unit ={
    var num = 10
    while (num>0){
      println(num)
      num = num-1
    }
  }

输出结果如下:

do … while 循环

  /**
    * do while循环
    */
  def doWhileLoop(): Unit ={
    var num = 10;
    do {
      println(num)
      num=num-1
    }while(num>0)
  }

for 循环

Scala的for循环特性被称之为for推导式或for表达式
for循环最简单的语法是

for(var x <- Range){
    ...
}

Range可以是数字范围，表示i到j的值。<font color=red> <-运算符</font>称之为生成器，它从一个范围中获取值

• 1、关键字to: i to j(包含j)

  /**
    * for循环
    */
  def forLoop(): Unit ={
    for (x <- 1 to 10){
      println(" x = "+x)

    }
  }

如下图，x的值输出了10

• 2、关键字until: i until j(不包含)

  def untilForLoop(): Unit ={
    var y = 10;
    for (y<- 1 until 10){
      println("y = " +y)
    }
  }

如下图，y的值不包含10

• 3、for循环多表达式

即嵌套for循环

  def for01(): Unit ={

    for (i<- 1 to 8 ; j<- 6 to 10){
      if (i==j){
        println(s"i=$i, j=$j")
      }
    }
  }

• 4、for循环与yield关键字

for循环中的yield关键字会将当前元素记录下来保存到集合中，结束循环后返回该集合。scala的for循环有返回值，返回值为被循环对象。

  /**
    * yeild 会将处理后的结果返回给list
    */
  def forWithYield(): Unit ={
    val list = for (i<- 1 to 10) yield i*2

    for(i<- list){
      println(i)
    }
  }

yield后可以跟表达式

1、yield关键字，在每次for循环会生成一个缓冲变量，循环结束之后，将buffer中的变量合并返回一个集合

2、合并返回的集合和循环中的数据类型一致。

• 5、for循环守卫

这种语法是scala和java的区别，循环守卫，又称循环保护,本质上就是条件判断。条件判断为TRUE时则进入循环体，否则跳出，类似java的continue关键字

  def for02(): Unit ={

    for (i<- 1 to 10 if i%2==0){
      println("符合条件的i = "+i)
    }

  }

上面的代码其实等价于

  def for03(): Unit ={

    for(i<- 1  to 10){
      if (i%2==0){
        println("符合条件的i = "+i)
      }
    }
  }

这就是scala的神奇之处，这样会削减代码量，后面还有很多类似的方式。

这里我们可以改造之前嵌套for循环的例子，如下

  def for001(): Unit ={

    for (i<- 1 to 8 ; j<- 6 to 10 if i==j){
      println("i和j的交集为：i=j="+i)
    }
  }

• 6、for循环与容器

  /**
    * for循环与list
    */
  def forLoopWithList(): Unit ={
    val list = List(1,2,3,4)
    for (i<- list){
      print("i = "+i)
    }
  }

注意事项：

scala的for循环表达式和java还是有很大区别的，但是基本原理是一样的。

课后作业

• 1、打印输出1~100以内的3的倍数的整数的个数以及这些和

  def result(): Unit ={
    var sum = 0;
    var totalNum = 0;
    for (i<- 1 to 100 if i%3==0){
      totalNum+=1
      sum+=i
    }
    println(s"100以内3的倍数的数有 sum=$sum, totalNum = $totalNum")
  }

以上内容有部分来自网上查阅的资料，如有版权问题。请与联系我:

email : liangliang1259@163.com

微信: 点击添加