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、常量的声明:

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

var str : String = "Scala"

2、变量的声明：

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

var number : Int = 2

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

2.2.3、数据类型

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

1、常用数据类型

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

数据类型	描述
Byte	同 java byte
Short	同 java short
Int	同 java int
Long	同 java long
Float	同 java float
Double	同 java Double
Char	同 java char
String	同 java String
Boolean	同 java boolean, true/false
Unit	无值，同 java void, 用于不返回结果的函数。Unit 只有一个实例值, 写成()

2、其他常用类型

数据类型	描述
Null	同 java null
Nothing	所有类的最底端，所有其他类型的子类型
Any	其他类的超类，所有类的父类
AnyRef	其他所有类的基类

如下图为 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 循环	同 java
do … while 循环
for 循环

循环控制语句

控制	描述
break	结束循环并执行循环下语句

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
微信: 点击添加