《Scala开发快速入门》

Nothing类型在Scala的类层级的最低端；它是任何其他类型的子类型。
Any是所有其他类的超类
Unit 表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。4
#for循环
scala> for(i<- 1 to 5){
println(“i=”+i)
}
1 to 5 [1,5]
1 until 5 [1,4]
scala> for (i<- 1 until(10,2)) println(i)
1
3
5
7
9
*scala语言中没有提供Java语言中的break、continue关键字
所以中断循环的办法
a、定义boolean类型的变量
b、引入Breaks类
for循环中加上关键字yield
yield利用前面缓存中得到的值生成一个集合并返回
https://www.cnblogs.com/codingexperience/p/5372617.html

第四章

*数组永远是可变的，列表List永远是不可变的、

4.1 集合

分为可变集合和不可变集合
scala.collection.immutable 不可变集合 函数式编程语言推崇使用这种集合，也是Scala默认导入的集合
scala.collection.mutable 可变集合
*集合层次

4.2 数组

分为定长数组和变长数组
val numArr = new ArrayInt
numArr(0) = 3
无new操作定义数组，实际上调用的是Array伴生对象的apply方法
变长数组ArrayBuffer
+= 向数组追加内容
++= 向数组追加对象内容，如Array，ArrayBuffer
数组的遍历

4.3 列表List

在头部进行增删操作，常量时间。对尾部进行操作的是线性的(正比于列表大小)
Nil空列表
:::连接操作
zip
toString
mkString
toArray 转化为数组
faltten 将列表平滑为第一个元素

4.4 集Set

元祖 Tuple，最大可以支持到Tuple22

第五章 函数

return是可以省略的
类型推导
若需要return关键字指定返回值，必须显式指定函数返回值的类型
若函数中存在递归调用，那么必须显式指定函数返回值的类型

5.2值函数

Scala中函数也是对象，也可以像变量一样被赋值，也可以被lazy修饰
Lambda函数
值函数：
val sum=(x:Int,y:Int)=>x+y
值函数不能在参数后面指定返回值类型
*值函数的各种简化方式

5.3 高阶函数

函数作为函数参数或者函数作为返回值
_相当于x=>x

5.4闭包 closure

对象，有方法的数据
闭包，有数据的方法
闭包可以理解为函数和上下文
存在开放到封闭过程的函数称之为闭包

5.5 函数柯里化

def multiply(x:Int)(y:Int)=xy
柯里化函数并不是高阶函数
def multiply(f:Int)(x:Double)=f*x
函数和方法的区别

第六章 类和对象

6.1类的定义

类的成员变量在声明时必须初始化
占位符 代表0或Null等
统一访问模式
[@_BeanProperty ](/BeanProperty ) 增加Java类型的get set方法，不能作用于private成员变量
单例对象，object
Scala中是不存在静态类成员的
extends App 可以不书写main入口来启动应用
*伴生对象和伴生类
无new创建对象—-》其实是调用伴生对象的apply方法
伴生对象，单例的。类似于Java中的静态类，其成员和方法都是静态的

6.2 主构造函数

默认参数的主构造函数
私有主构造函数

6.3 辅助构造函数

this()

6.4 继承与多态

1、继承 extends
2、多态 Polymorphic 也被称为动态绑定
指在执行期间，而不是编译期间，确定所引用对象的实际类型。
即子类的引用可以赋给父类，程序在运行过程中根据其实际类型调用对应方法

6.5成员访问控制

Java中的访问控制权限:
public 当前包、子类和其他包都可以访问，即没有限制
protected 当前包和子类可以访问
package 当前包内可以访问
private 只有当前类可以访问
Scala中的访问权限控制,三种
默认—>public
protected
private
*Scala中没有public关键字
private[this] 类的私有成员
与private的区别在于，伴生对象的访问权限

6.6 抽象类

不能被实例化的类
普通类成员变量在定义时必须显式初始化，否则会报错

6.7 内部类和内部对象

调用伴生类对象的内部类方法 new student.Grade(“一年级”).name
调用伴生类对象的内部对象方法 student.Utils1.print
调用伴生对象的内部类的方法 new Student.Printer().print
调用伴生对象的内部对象 Student.Util2.print

第七章 Scala面向对象编程

7.1 trait简介

Scala中没有interface关键字，而是提供了trait关键字来封装方法和变量
*trait 特质，一个类只能有一个父类，但是可以有混入多个trait
使用时通过extends和with关键字来混入(mix)trait,近似实现了多继承。
混入的第一个trait使用extends关键字，之后的使用with关键字

7.2 trait的使用

trait类似于抽象类，可以有抽象成员/方法，具体成员/方法
只含有抽象成员/方法的trait，类似于Java中的interface
混入trait的类构造顺序
*提前定义和懒加载—>解决空指针异常的问题
lazy,将创建对象的工作后移，等到真正执行到时，对象已经创建好了。这时就不会有程序运行时的空指针异常问题

7.3 trait和类

trait类似于抽象类
trait和类的不同点
a.trait不能在类定义时使用主构造函数定义类的成员变量,但是普通类和抽象类都可以
b.类不能继承多个类，但是可以混入多个trait

7.4 多重继承问题

菱形继承—最右深度优先遍历
解决菱形继承—》super()

7.5 自身类型

任何混入特质的具体类，都必须确保它的类型符合特质的自身类型
自身类型最通常的应用是将大类分为若干个小类

  1. this:B => 标记这个trait A的自身类型为B

第八章 包(Package)

8.2 包的使用和作用域

scala允许在任何地方进行包的引入

  • private[this] 限定只有本类的对象才能访问，在外部不能访问，即使是伴生对象也不能

    8.3 包对象

    主要用于对常量和工具函数的封装
    package class

    8.4 import高级特性

    默认引入—>
    import scala.Predef.
    import java.lang.
    重命名java.util.{HashMap=>JavaHashMap}
    类隐藏java.util.{HashMap=>,} 将HashMap隐藏，util下的其余类全部引入

    第九章 模式匹配

    9.1 简介

    match case..
    模式匹配还可以作为函数体，其结果作为函数返回值

    9.2 模式匹配的七大类型

    1. 3 构造函数模式  相当于是析构函数
    2. 4 序列模式            
    3. 5 元祖模式        
    4. 6 类型模式        
    5. 7 变量绑定模式

9.3 模式匹配原理

  1. 1 构造函数模式<br />        普通class 需要显式定义Dog类的伴生对象，并在其中实现unapply方法<br />        case class  编译器会自动帮我们生成该类的伴生对象，及其apply和unapply对象<br />    2 序列模式匹配<br />        没有使用unapply方法，而是unapplySeq方法

9.4 正则表达式和模式匹配

val regx = “””(\d\d\d)-(\d\d)-(\d\d)”””.r
scala.util.matching.Regex
正则表达式也是通过unapply方法来实现模式匹配的

9.5 for循环中的模式匹配

9.6 模式匹配与样例类、样例对象

模式匹配与样例类是一对孪生兄弟，经常一起使用
sealed trait 在子类众多时，模式匹配，需要处理较复杂的情况时，可以这样使用

第十章 隐式转换

预导入的Predef对象，拥有一系列的隐式转换函数
implicit

10.2 隐式转换函数

implicit def float2int(x:Float) = x.toInt
隐式转换函数与函数名称无关，只与函数签名有关。

10.3 隐式类与隐式对象

1、隐式类
scala> implicit class Dog(val name:String){
def bark = println(s”$name is barking”)
}
defined class Dog
scala> “HH”.bark
HH is barking
隐式类的主构造函数参数，有且只有一个
隐式类的作用原理是通过隐式转换函数来实现的
2、隐式对象

10.4 隐式参数与隐式值

第十一章 类型参数

11.1 类和类型

11.2 泛型

1泛型类
2泛型接口和泛型方法
3类型通配符
Java中提供了类型通配符上限和下限，Scala中提供了类似功能，但是还有其他更灵活更复杂的用法(存在类型)
存在类型 类[T] forSome {type T} 或者类[_]

11.3 类型变量界定

is a
T <: Comparable[T] 所有实现了Comparable的子类都可以，即这里限制了T的最顶层类，即上界
R >: T 即这里限制了T的最底层类，即下界

11.4 视图界定 can be seen as

T <% Comparable[T]
类型变量界定要求类在类的集成层次结构上，而视图界定不但可以在类继承层次上，还可以跨越类继承层次结构。支持隐式转换

11.5 上下文界定 has a

T:M

11.6 多重界定

11.7 协变与逆变

非变：与Java一致
协变 class List+T
逆变 -

11.8 高级类型

https://www.cnblogs.com/harvey888/p/6246471.html Scala中:: , +:, :+, :::, ++的区别
https://www.cnblogs.com/mustone/p/5648914.html Scala 技术笔记之Option Some None
Scala
Option
None和Some都是Option子类
Scala应用推荐使用Option类型来代表一些可选值。使用Option类型，读者一眼就可以看出这种类型的值可能为None
scala _
Enumeration
在Scala中并没有枚举类型，但在标准类库中提供了Enumeration类来产出枚举。扩展Enumeration类后，调用Value方法来初始化枚举中的可能值

https://docs.scala-lang.org/zh-cn/overviews/collections/concrete-immutable-collection-classes.html# 官方的Collection集合介绍