第01章 Scala概述

1. Scala快速开发入门

1. Scala源文件以 “.scala" 为扩展名

2. ala程序的执行入口是main()函数

3. Scala语言严格区分大小写。

4. Scala方法由一条条语句构成，每个语句后不需要分号(Scala语言会在每行后自动加分号)，这也体现出Scala的简洁性。

5. 如果在同一行有多条语句，除了最后一条语句不需要分号，其它语句需要分号(尽量一行就写一条语句)。
   Scala语言输出的三种方式

2. Scala语言输出的三种方式

object PrintTest {def main(args: Array[String]): Unit = {val name = "ApacheCN"val age  = 1val url  = "www.atguigu.com"//一、字符串通过“+” 连接（类似Java）println("name=" + name + " age=" + age + " url=" + url)//二、printf（类似C语言）字符串通过%传值。（格式化输出）printf("name=%s, age=%d, url=%s \n",name,age,url)//三、字符串插值：通过$引用（类似PHP）println(s"name=$name, age=$age, url=$url")//使用插值并能够格式化println(f"name=$name, age=$age%.2f, url=$url \n")//对字符串不作任何处理print(raw"name=$name, age=$age%.2f, url=$url \n")}
}

第02章 变量

变量相当于内存中一个数据存储空间的表示，你可以把变量看做是一个房间的门牌号，通过门牌号我们可以找到房间，而通过变量名可以访问到变量(值)。

Scala变量使用说明

变量声明基本语法
var | val 变量名 [: 变量类型] = 变量值

注意事项

1. 声明变量时，类型可以省略（就是叫 类型推断）

2. 类型确定后，就不能修改，说明Scala 是强数据类型语言

3. 在声明/定义一个变量时，可以使用var 或者 val 来修饰， var 修饰的变量可改变，val 修饰的变量不可改

4. val修饰的对象属性在编译后，等同于加上final

5. var 修饰的对象引用可以改变，val 修饰的则不可改变，但对象的状态(值)却是可以改变的。(比如: 自定义对象、数组、集合等等)

class Dog {var age  = 100
}

6. 变量声明时，必须有初始值（显示初始化），如果不确定初始化值，可以使用_，由系统给初始化值。

数据类型

1. 数据类型介绍

1. Scala 与 Java有着相同的数据类型，在Scala中数据类型都是对象，也就是说scala没有java中的原生(基本)类型

2. Scala数据类型分为两大类 AnyVal(值类型) 和 AnyRef(引用类型)， 注意：不管是AnyVal还是AnyRef 都是对象。

3. 相对于java的类型系统，scala要复杂些！也正是这复杂多变的类型系统才让面向对象编程和函数式编程完美的融合在了一起

 var num1 : Int = 10println("num1" + num1)var char1 : Char = 'a'println("char1的code= " + char1.toInt)

2. Scala数据类型体系一览图

3. Scala数据类型列表

1. 整数类型

1. 整型的类型

2. 整型的使用细节

1）Scala各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保证Scala程序的可移植性。

2）Scala的整型 常量/字面量 默认为 Int 型，声明Long型 常量/字面量 须后加‘l’’或‘L’

3）Scala程序中变量常声明为Int型，除非不足以表示大数，才使用Long

2. 浮点类型

1. 浮点类型分类

2. 浮点型使用细节

1）与整数类型类似，Scala 浮点类型也有固定的表数范围和字段长度，不受具体OS的影响。
2）Scala的浮点型常量默认为Double型，声明Float型常量，须后加‘f’或‘F’。
3）浮点型常量有两种表示形式
十进制数形式：如：5.12 512.0f .512 (必须有小数点）
科学计数法形式:如：5.12e2 => 5.12 乘以 10的2次方 5.12E-2 =》 表示5.12 除以 10的2次方
4) 通常情况下，应该使用Double型，因为它比Float型更精确(小数点后大至7位) 测试数据 ：2.2345678912f , 2.2345678912 // 2.7 与 8.1/3

3. 字符类型

1. 基本介绍

字符类型可以表示单个字符,字符类型是Char， 16位无符号Unicode字符(2个字节), 区间值为 U+0000 到 U+FFFF

2. 字符类型使用细节

1）字符常量是用单引号(‘ ’)括起来的单个字符。例如：var c1 = 'a‘ var c2 = '中‘ var c3 = ‘9’

2）Scala 也允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。例如：var c3 = ‘\n’ // '\n’表示换行符

3）可以直接给Char赋一个整数，然后输出时，会按照对应的unicode 字符输出 [’\u0061’ 97]

4）Char类型是可以进行运算的，相当于一个整数，因为它都对应有Unicode码.

问题：
var c2 : Char = ‘a’ + 1 正确吗? （×）
修改: var c2 : Int = ‘a’ + 1 [ok]

4. 布尔类型：Boolean

基本介绍

1）布尔类型也叫Boolean类型，Booolean类型数据只允许取值true和false

2）boolean类型占1个字节

3）boolean 类型适于逻辑运算，一般用于程序流程控制：
if条件控制语句
while循环控制语句
do-while循环控制语句
for循环控制语句

5. Unit类型、Null类型和Nothing类型

1. 基本说明

2. 使用细节和注意事项

1）Null类只有一个实例对象，null，类似于Java中的null引用。null可以赋值给任意引用类型(AnyRef)，但是不能赋值给值类型(AnyVal: 比如 Int, Float, Char, Boolean, Long, Double, Byte, Short)

2）Unit类型用来标识过程，也就是没有明确返回值的函数。由此可见，Unit类似于Java里的void。Unit只有一个实例，()，这个实例也没有实质的意义

3）Nothing，可以作为没有正常返回值的方法的返回类型，非常直观的告诉你这个方法不会正常返回，而且由于Nothing是其他任意类型的子类，他还能跟要求返回值的方法兼容。

4. 值类型转换

1. 值类型隐式转换

当Scala程序在进行赋值或者运算时，精度小的类型自动转换为精度大的数据类型，这个就是自动类型转换(隐式转换 implicit conversion)。
数据类型按精度(容量)大小排序为

2. 自动类型转换细节说明

1）有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。
2）当我们把精度(容量)大 的数据类型赋值给精度(容量)小 的数据类型时，就会报错，反之就会进行自动类型转换。
3）(byte, short) 和 char之间不会相互自动转换。
4）byte，short，char 他们三者可以计算，在计算时首先转换为int类型。
5）自动提升原则： 表达式结果的类型自动提升为 操作数中最大的类型

3. 强制类型转换

自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转函数，但可能造成精度降低或溢出,格外要注意。
强值类型转换注意事项
1）当进行数据的 从 大——>小，就需要使用到强制转换

2）强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级
Char类型可以保存 Int的常量值，但不能保存Int的变量值，需要强转

3）Byte和Short类型在进行运算时，当做Int类型处理。

5. 值类型和String类型的转换

在程序开发中，我们经常需要将基本数据类型转成String 类型。或者将String类型转成基本数据类型。

1. 基本类型转String类型

2. String类型转基本数据类型

注意事项

在将String 类型转成 基本数据类型时，要确保String类型能够转成有效的数据，比如 我们可以把 “123” , 转成一个整数，但是不能把 “hello” 转成一个整数

4. 标识符的命名规范

1. 标识符概念

1）Scala 对各种变量、方法、函数等命名时使用的字符序列称为标识符
2）凡是自己可以起名字的地方都叫标识符

2. 标识符的命名规则

Scala中的标识符声明，基本和Java是一致的，但是细节上会有所变化。

1）首字符为字母，后续字符任意字母和数字，美元符号，可后接下划线_
2）数字不可以开头。
3）首字符为操作符(比如+ - * / )，后续字符也需跟操作符 ,至少一个
操作符(比如±*/)不能在标识符中间和最后.
4）用反引号(飘号)....包括的任意字符串，即使是关键字(39个)也可以

3. 标识符命名注意事项

1）包名：尽量采取有意义的包名，简短，有意义

2）变量名、函数名 、方法名 采用驼峰法。

4. Scala有39个关键字

package, import, class, object, trait, extends, with, type, for
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

第03章 运算符

1. 运算符介绍

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等

1）算术运算符

2）赋值运算符

3）比较运算符(关系运算符)

4）逻辑运算符【与，或，非】

5）位运算符 (位运算 ~ | ^ >> << >>>…)

2. 算术运算符

注意事项
1）对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。 例如：var x : Int = 10/3 ,结果是 3

2）当对一个数取模时，可以等价 a%b=a-a/b*b ， 这样我们可以看到取模的一个本质运算(和java 的取模规则一样)。

3）注意：Scala中没有++、–操作符，需要通过+=、-=来实现同样的效果

第04章 程序流程控制

1. 程序流程控制介绍

在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌握的，主要有三大流程控制语句。

温馨提示： Scala语言中控制结构和Java语言中的控制结构基本相同，在不考虑特殊应用场景的情况下，代码书写方式以及理解方式都没有太大的区别

1）顺序控制
2）分支控制（单分支, 双分支，多分支）
3）循环控制

1. 顺序控制

程序从上到下逐行地执行，中间没有任何判断和跳转。
顺序控制举例和注意事项
Scala中定义变量时采用合法的前向引用。如：
def main(args : Array[String]) : Unit = {
var num1 = 12
var num2 = num1 + 2
}
错误形式：
def main(args : Array[String]) : Unit = {
var num2 = num1 + 2
var num1 = 12
}

2.分支控制if-else

让程序有选择的的执行,分支控制有三种:
1）单分支
2）双分支
3）多分支

1. 单分支

基本语法
if (条件表达式) {
执行代码块
}
**说明：**当条件表达式为ture 时，就会执行 { } 的代码。

2. 双分支

基本语法
if (条件表达式) {
执行代码块1
} else {
执行代码块2
}
说明：当条件表达式成立，即执行代码块1，否则执行代码块2.

3. 多分支

基本语法
if (条件表达式1) {
执行代码块1
}
else if (条件表达式2) {
执行代码块2
}
……
else {
执行代码块n
}

4. 分支控制if-else 注意事项

1）如果大括号{}内的逻辑代码只有一行，大括号可以省略, 这点和java 的规定一样。

2）Scala中任意表达式都是有返回值的，也就意味着if else表达式其实是有返回结果的，具体返回结果的值取决于满足条件的代码体的最后一行内容.

3）Scala中是没有三元运算符，因为可以这样简写

5. 嵌套分支

在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构称为内层分支外面的分支结构称为外层分支。嵌套分支不要超过3层

3. 循环控制

1. for循环控制

基本介绍
Scala 也为for 循环这一常见的控制结构提供了非常多的特性，这些for 循环的特性被称为for 推导式（for comprehension）或for 表达式（for expression）

1. 范围数据循环方式1

基本案例
for(i <- 1 to 3){
print(i + " ")
}
println()
说明
1）i 表示循环的变量， <- 规定好 to 规定
2）i 将会从 1-3 循环， 前后闭合 （包括1 和 3）
输出10句 “hello,尚硅谷!”

2. 范围数据循环方式2

基本案例
for(i <- 1 until 3) {
print(i + " ")
}
println()
说明:
1）这种方式和前面的区别在于 i 是从1 到 (3-1)
2）前闭合后开的范围,和java的arr.length() 类似
for (int i =0; i < arr.lenght(); i++ ){}
输出10句 “hello,尚硅谷!”

3. 循环守卫

基本案例
for(i <- 1 to 3 if i != 2) {
print(i + " ")
}
println()

基本案例说明
循环守卫，即循环保护式（也称条件判断式，守卫）。保护式为true则进入循环体内部，为false则跳过，类似于continue
上面的代码等价
for (i<-1 to 3){
if ( i != 2) {
println(i+" ")
}
}

4. 引入变量

基本案例
for(i <- 1 to 3; j = 4 - i) {
print(j + " ")
}

对基本案例说明
没有关键字，所以范围后一定要加；来隔断逻辑
上面的代码等价

for (i <- 1 to 3) {
var j = 4 – i
print(j + “ “)
}

5. 嵌套循环

基本案例
for(i <- 1 to 3; j <- 1 to 3) {
println(" i =" + i + " j = " + j)
}

对基本案例说明
没有关键字，所以范围后一定要加；来隔断逻辑
上面的代码等价
for (i <- 1 to 3) {
for (j <-1 to 3) {
println(“ok”)
}
}

6. 循环返回值

基本案例
val res = for(i <- 1 to 10) yield i * 2
println(res)

对基本案例说明
将遍历过程中处理的结果返回到一个新Vector集合中，使用yield关键字

7. 使用花括号{}代替小括号()

基本案例
for{i <- 1 to 3; j = i * 2} {
println(" i= " + i + " j= " + j)
}

对基本案例说明
{}和()对于for表达式来说都可以
for 推导式有一个不成文的约定：当for 推导式仅包含单一表达式时使用圆括号，当其包含多个表达式时使用大括号
当使用{} 来换行写表达式时，分号就不用写了

8. 注意事项和细节说明

1）scala 的for循环形式和java是较大差异，这点请同学们注意，但是基本的原理还是一样的。

2）scala 的for循环的步长如何控制! [for(i <- Range(1,3,2)]

2. while循环控制

1. while循环控制

1. 基本语法

循环变量初始化 //循环的四个要素
while (循环条件) {
循环体(语句)
循环变量迭代
}

2. 注意事项和细节说明

1）循环条件是返回一个布尔值的表达式

2）while循环是先判断再执行语句

3）与If语句不同,While语句本身没有值,即整个While语句的结果是Unit类型的()

4）因为while中没有返回值,所以当要用该语句来计算并返回结果时,就不可避免的使用变量 ，而变量需要声明在while循环的外部，那么就等同于循环的内部对外部的变量造成了影响，所以不推荐使用，而是推荐使用for循环。

2. do…while循环控制

1. 基本语法

循环变量初始化;
do{
循环体(语句)
循环变量迭代
} while(循环条件)

2. 注意事项和细节说明

循环条件是返回一个布尔值的表达式
do…while循环是先执行，再判断
和while 一样，因为do…while中没有返回值,所以当要用该语句来计算并返回结果时,就不可避免的使用变量 ，而变量需要声明在do…while循环的外部，那么就等同于循环的内部对外部的变量造成了影响，所以不推荐使用，而是推荐使用for循环

3. 多重循环控制

介绍：

1）将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while均可以作为外层循环和内层循环。【建议一般使用两层，最多不要超过3层】

2）实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。

3）设外层循环次数为m次，内层为n次， 则内层循环体实际上需要执行 m * n次。

4. 循环的中断

基本说明
Scala内置控制结构特地去掉了break和continue，是为了更好的适应函数化编程，推荐使用函数式的风格解决break和contine的功能，而不是一个关键字。

5. while循环的中断

如何实现continue的效果
Scala内置控制结构特地也去掉了continue，是为了更好的适应函数化编程，可以使用if – else 或是 循环守卫实现continue的效果

案例演示 : 遍历 1 到 10,当 为 4和5的时候，跳过执行。

for(i <- 1 to 10){
if (i != 4 && i != 5) {
执行.
}
}
for(i <- 1 to 10 if i (!=4 && i != 5)) {
执行…
}