Scala知识点总结

# Scala知识点总结

1. 什么是Scala
Scala是一门以Java虚拟机（JVM）为运行环境并将面向对象和函数式编程的最佳特性结合在一起的静态类型编程语言。

2. Scala 的特点
1）多范式的编程语言,支持面向对象和函数式编程。
2) 可以调用现有的Java类库，实现两种语言的无缝对接。
3) 简洁高效。
4) Scala是源于Java,只要在学习Scala的过程中，搞清楚Scala和Java相同点和不同点，就可以快速的掌握Scala这门语言。
5) 函数是头等公民

3. Scala和java 有什么区别？
1）变量的声明
Scala 变量var 常量val 支持自动类型推测
2）函数的声明
关键字def, Scala函数没有返回值用Unit，相当于java的void
Scala支持函数式编程,可以使用高阶函数 函数是一等公民
3）Scala中不支持Break
使用return替代,在循环中用if和布尔类型变量进行守卫
导入java中支持break的包
4) 通配符
Java使用*进行通配,Scala使用 _ 进行通配
5) 基本类型
其实可以认为Scala中并没有真正意义上的基本类型,他的类型都是类

4. val 和var的区别？
var修饰的变量可改变,val修饰的变量不可改。

5. Scala的数据类型？
数值类型（AnyVal）、引用类型（AnyRef）
1) 整数类型:Byte、Short、Int、Long
2) 浮点类型:Float、Double
3) 字符类型:Char
4) 布尔类型:Boolean
5) Unit类型、Null类型和Nothing类型

6. Scala 运算符
1) 算术运算符
+ 正号
- 负号
+ 加
- 减
* 乘
/ 除
% 取模(取余)
+ 字符串相加
2) 关系运算符
== 相等于
!= 不等于
< 小于
> 大于
<= 小于等于
>= 大于等于
3) 逻辑运算符
&& 逻辑与
|| 逻辑或
! 逻辑非
4) 赋值运算符
= 简单的赋值运算符，将一个表达式的值赋给一个左值
+= 相加后再赋值
-= 相减后再赋值
*= 相乘后再赋值
/= 相除后再赋值
%= 求余后再赋值
<<= 左移后赋值
>>= 右移后赋值
&= 按位与后赋值
^= 按位异或后赋值
|= 按位或后赋值
5) 位运算符
& 按位与运算符
| 按位或运算符
^ 按位异或运算符
~ 按位取反运算符
<< 左移动运算符
>> 右移动运算符
>>> 无符号右移

7. Scala块语句有什么特点？
最后一行可以当作返回值 直接返回

8. Scala break使用?
> import util.control.Breaks._ 导包
>
> breakable {
>
> 循环语句{
>
> if(){
>
> break() / /调用break() 方法
>
> }
>
> }
>
> }
>
> > 创建 new Breaks() 对象
> >
> > 调用break()

9. Scala 函数和方法的区别？
1）为完成某一功能的程序指令（语句）的集合，称为函数。
2）类中的函数称之方法。
3) 函数没有重载和重写的概念;方法可以进行重载和重写。

10. Scala 函数的参数？
Scala () 参数
声明 参数名与类型
对声明参数名与类型 进行赋值 (默认值)
最后一个参数可声明位 可变参数 参数类型后跟*

11. Scala 方法的几种写法？
def test1():Unit = {
hello.print("test1():Unit----> 无参无返回值")
}

def test2():String = {
/* 函数块最后一行可以最为返回值*/
"test2():String----> 无参有返回值"
}

def test3(str:String):Unit = {
hello.print(str + "test3(str:String):Unit --->有参无返回值")
}
def test4(str:String):Int = {
hello.print(str + "test4(str:String):Int --->有参有返回值")
1
}
12. Scala 函数的写法
Scala
/*
> sum(函数名)
> (Int,Int) 函数类型
> (a:Int,b:Int) 函数字面量
> */
val sum :(Int,Int) => Int = (a:Int,b:Int) => x+y

/* 匿名函数*/ (x: Int, y: Int) => x + y
// 可以赋值给变量 调用 var sum = (x:Int,y:Int) => x + y
// 可以简写 _ 所有的元素 _ + _

13. Scala 闭包？
就是一个函数和与其相关的引用环境（变量）组合的一个整体(实体)

14. Scala 柯里化？
将一个接收多个参数的函数转化成一个接受一个参数的函数过程，可以简单的理解为一种特殊的参数列表声明方式。

15. Scala 函数至简原则？
能省则省

16. Scala lazy？
Lazy懒加载，当被调用得时候才会被执行

17. Scala包的三大作用
1）区分相同名字的类
2）当类很多时，可以很好的管理类
3）控制访问范围

18. Scala 中的三个默认导入包？
Scala中的三个默认导入分别是
import java.lang._
import Scala._
import Scala.Predef._

19. Scala 访问修饰符，及作用域？
在Java中，访问权限分为：public，private，protected和默认。在Scala中，你可以通过类似的修饰符达到同样的效果。但是使用上有区别。
1）Scala 中属性和方法的默认访问权限为public，但Scala中无public关键字。
2）private为私有权限，只在类的内部和伴生对象中可用。
3）protected为受保护权限，Scala中受保护权限比Java中更严格，同类、子类可以访问，同包无法访问。
4）private[包名]增加包访问权限，包名下的其他类也可以使用

20. Scala @BeanProperty 属性的特点？
为该属性 提供类似java 的 getter setter 方法

21. Scala var和val 修饰的对象有什么区别？
属性: [修饰符] var 属性名称 [：类型] = 属性值
方法:
def 方法名(参数列表) [：返回值类型] = { 方法体}
1）val修饰对象，不能改变对象的引用（即：内存地址），可以改变对象属性的值。
2）var修饰对象，可以修改对象的引用和修改对象的属性值
3) 子类中重写 val 声明的属性 需要使用关键字 ==override==
4） 子类重写父类 方法必须加 ==override== 关键字

22. Scala 的构造器？
一个class 是一个主构造器
内部构造器与主class重名(this) 参数列表不同 (必须先调用主构造器) 可以有多个辅助构造器
类似java中的重载

23. Scala 的继承？
子类继承父类中 公共的属性和方法

24. Scala 的抽象类？
trait 类中 全部都是抽象的 可以是 属性 方法(只有定义没有实现)
abstract 修饰的类也是抽象类 (只有定义没有实现)

25. Scala 的内部类访问的方法？
1) 通过new 外部类 在 new (外部类 ming). 内部类 获取
2) 通过外部类方法返回内部类对象

26. Scala object特点？
object 里全部都是静态的

27. Scala 伴生类和伴生对象？
1）单例对象采用object关键字声明
2）单例对象对应的类称之为伴生类，伴生对象的名称应该和伴生类名一致。
3）单例对象中的属性和方法都可以通过伴生对象名（类名）直接调用访问。

28. Scala 的apply？
1）通过伴生对象的apply方法，实现不使用new方法创建对象。
2）如果想让主构造器变成私有的，可以在()之前加上private。
3）apply方法可以重载。

29. Scala 的特质trait？
Trait 类中 只能存放 属性方法的 声明定义 (代替java接口 interface)

30. Scala 的类型检查和类型转换？
1）obj.isInstanceOf[T]：判断obj是不是T类型。
2）obj.asInstanceOf[T]：将obj强转成T类型。
3）classOf获取对象的类名。

31. Scala 数组？
不可变数组
1）第一种方式定义数组(定长数组)

定义：val arr1 = new Array[Int](10)
（1）new是关键字
（2）[Int]是指定可以存放的数据类型，如果希望存放任意数据类型，则指定Any
（3）(10)，表示数组的大小，确定后就不可以变化

定义数组
val arr1 = Array(1, 2)
（1）在定义数组时，直接赋值
（2）使用apply方法创建数组对象

可变数组
1）定义变长数组
val arr01 = ArrayBuffer[Any](3, 2, 5)
（1）[Any]存放任意数据类型
（2）(3, 2, 5)初始化好的三个元素
（3）ArrayBuffer需要引入Scala.collection.mutable.ArrayBuffer
ArrayBuffer是有序的集合
（4）增加元素使用的是append方法()，支持可变参数

不可变数组与可变数组的转换
1）说明
arr1.toBuffer //不可长数组转可变数组
arr2.toArray //可变数组转不可变数组
（1）arr2.toArray返回结果才是一个不可变数组+，arr2本身没有变化
（2）arr1.toBuffer返回结果才是一个可变数组，arr1本身没有变化

多维数组
1）多维数组定义

val arr =Array.ofDim[Double](3,4)
说明：二维数组中有三个一维数组，每个一维数组中有四个元素

32. Scala list
不可变List
1）说明
（1）List默认为不可变集合
（2）创建一个List（数据有顺序，可重复）
（3）遍历List
（4）List增加数据
（5）集合间合并：将一个整体拆成一个一个的个体，称为扁平化
（6）取指定数据
（7）空集合Nil

可变ListBuffer
1）说明
（1）创建一个可变集合ListBuffer
（2）向集合中添加数据
（3）打印集合数据

33. Scala map
Scala中的Map和Java类似，也是一个散列表，它存储的内容也是键值对（key-value）映射，Scala中不可变的Map是有序的，可变的Map是无序的。

34. Scala set
默认情况下，Scala使用的是不可变集合，如果你想使用可变集合，需要引用Scala.collection.mutable.Set包
不可变Set
1）说明
（1）Set默认是不可变集合，数据无序
（2）数据不可重复
（3）遍历集合

不可变mutable.Set
1）说明
（1）创建可变集合mutable.Set
（2）打印集合
（3）集合添加元素
（4）向集合中添加元素，返回一个新的Set
（5）删除数据

35. Scala 集合的head tail Nil？
构造列表是有两个基本类型Nil和:: //Nill也可以表示一个空列表
Scala列表有三个基本操作
head返回列表第一个元素tail返回一个列表，包含除了第一个元素之外的其他元素isEmpty在列表为空时返回true

36. Scala 的并行集合？
Scala为了充分使用多核CPU，提供了并行集合（有别于前面的串行集合），用于多核环境的并行计算。

37. Scala 的队列？
Scala也提供了队列（Queue）的数据结构，队列的特点就是先进先出。进队和出队的方法分别为enqueue和dequeue。

38. Scala 样例类特点？

1）样例类仍然是类，和普通类相比，只是其自动生成了伴生对象，并且伴生对象中自动提供了一些常用的方法，如apply、unapply、toString、equals、hashCode和copy。

2）样例类是为模式匹配而优化的类，因为其默认提供了unapply方法，因此，样例类可以直接使用模式匹配，而无需自己实现unapply方法。
3）构造器中的每一个参数都成为val，除非它被显式地声明为var（不建议这样做）

39. Scala 模式匹配？
Scala中的模式匹配相当于Java中的switch语法，但是更加强大。
模式匹配中，使用关键字 match 声明，每个分支使用 关键字 case 声明，如果匹配成功，就不会执行下一个分支，反之会一一匹配。
如果所有的case都不匹配，会执行 case _ 分支 或者 case someThing （相当于Java的Switch-case中的default）
Scala 中，模式匹配可以匹配所有的字面量，包括字符串，字符，数字，布尔值等等。

40. Scala 偏函数？
偏函数也是函数的一种，通过偏函数我们可以方便的对输入参数做更精确的检查。例如该偏函数的输入类型为List[Int]，而我们需要的是第一个元素是0的集合，这就是通过模式匹配实现的。

41. Scala 异常？
1）不管有没有异常捕获，都会执行finally，因此通常可以在finally代码块中释放资源。
2）可以有多个catch，分别捕获对应的异常，这时需要把范围小的异常类写在前面，把范围大的异常类写在后面，否则编译错误。

42. Scala 隐式转换那些，有什么特点？
（1）首先会在当前代码作用域下查找隐式实体（隐式方法、隐式类、隐式对象）。（一般是这种情况）
（2）如果第一条规则查找隐式实体失败，会继续在隐式参数的类型的作用域里查找。类型的作用域是指与该类型相关联的全部伴生对象以及该类型所在包的包对象
隐式函数：隐式转换可以再不需改任何代码的情况下，扩展某个类的功能。
隐式参数：普通方法或者函数可以通过implicit关键字声明隐式参数，调用该方法时，就可以传入该参数，编译器会再相应的作用域寻找符合条件的隐式值。
1）同一个作用域中，相同类型的隐式值只能有一个
2）编译器按照隐式参数的类型去寻找对应类型的隐式值，与隐式值的名称无关。
3）隐式参数优先于默认参数
隐式类：可以使用implicit声明类，隐式类的非常强大，同样可以扩展类的功能，在集合中隐式类会发挥重要的作用。
1）其所带的构造参数有且只能有一个
2）隐式类必须被定义在“类”或“伴生对象”或“包对象”里，即隐式类不能是顶级的。

43. Scala的协变逆变
1）语法
class MyList[+T]{ //协变
}
class MyList[-T]{ //逆变
}
class MyList[T] //不变
2）说明
协变：Son是Father的子类，则MyList[Son] 也作为MyList[Father]的“子类”。
逆变：Son是Father的子类，则MyList[Son]作为MyList[Father]的“父类”。
不变：Son是Father的子类，则MyList[Father]与MyList[Son]“无父子关系”。

44. Scala 的上下限约束？
下边界 >: 传入的参数只能是其本身或者是其父类
上边界 <: 传入的参数只能是其本身或者是其子类