二、Scala基础知识

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的数据类型基本一致

数据类型	描述
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 : [e-mail]
微信: 点击添加