二Scala基础知识

jiezi

5 年前

谁适合阅读本教程？

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

1、解释器
2、基础语法
3、函数
4、条件与循环

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

CTRL+C退出交互模式

类似于我们在命令行通过 java *.java 执行 一样，我们通过记事本创建一个文件 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, 看到如下输出结果

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

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

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

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

var str : String = "Scala"

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

var number : Int = 2

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

scala 所有的数据类型都是对象，没有 java 的原生基本类型

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 只有一个实例值, 写成()

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

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

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 的重合的地方

1、字母标识符

以字母或者下划线开头，之后可以跟字母数字或者下划线。不能使用 $，尽管可以编译通过
Scala 遵循 java 的驼峰式标识符，因此尽管下划线是合法的，但是为了同 java 保持一致，尽量不要使用

2、操作标识符

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

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

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}
}

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

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

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

方法转函数

  val plus = add _

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

同 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 中的入口类

  /**
    * 条件语句
    * @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 之间")
      }
    }

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

循环类型	描述
while 循环	同 java
do … while 循环
for 循环

循环控制语句

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

  /**
    * 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 的值。 <- 运算符 称之为生成器，它从一个范围中获取值

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

二Scala基础知识

Scala 基础知识

学习任务

2.1、Scala 解释器

2.1.1、交互模式

2.1.2、脚本模式

2.2、基础语法

2.2.1、基础内容普及

2.2.2、变量与常量

1、常量的声明:

2、变量的声明：

2.2.3、数据类型

1、常用数据类型

2、其他常用类型

2.2.4、关键字与标识符

1、关键字

2、标识符

2.3、方法与函数

2.3.1、方法的定义与调用

方法的定义

方法的调用

2.3.2、函数的定义与调用

函数的定义

函数的调用

2.3.3、主函数

2.4、条件与循环

2.4.1、条件

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

2、嵌套 if

2.4.2、循环

while 循环

do … while 循环

for 循环

课后作业