抽象类
抽象属性和抽象方法
分为定义抽象，定义抽象属性，定义抽象方法
定义抽象类：abstract class Person{} //通过 abstract 关键字标记抽象类
定义抽象属性：val|var name:String //一个属性没有初始化，就是抽象属性
定义抽象方法：def hello():String //只声明而没有实现的方法，就是抽象方法（声明没有落实到实处）
案例实操
abstract class Person {
val name: String
def hello(): Unit
}
val name: String = "teacher"
def hello(): Unit = {
println("hello teacher")
}
}
继承和重写
- 如果父类为抽象类，那么子类需要将抽象的属性和方法实现，否则子类也需声明为抽象类
- 重写非抽象方法需要用 override 修饰，重写抽象方法则可以不加 override。
- 子类中调用父类的方法使用 super 关键字
- 子类对抽象属性进行实现，父类抽象属性可以用 var 修饰；子类对非抽象属性重写，父类非抽象属性只支持 val 类型，而不支持 var。因为 var 修饰的为可变变量，子类继承之后就可以直接使用，没有必要重写
匿名子类
通过代码块的形式创建匿名子类。（就是没有一个全新的名字，直接通过重写代码块的形式创建了一个匿名子类）
单例对象（伴生对象）
Scala语言是完全面向对象的语言，所以并没有静态的操作（即在Scala中没有静态的概念）。但是为了能够和Java语言交互（因为Java中有静态概念），就产生了一种特殊的对象来模拟类对象，该对象为单例对象。若单例对象名与类名一致，则称该单例对象这个类的伴生对象，这个类的所有“静态”内容都可以放置在它的伴生对象中声明。
（Scala两个编程特点，一个是函数式编程，另一个是面向对象编程）
单例对象语法
基本语法
object Person{
val country:String="China"
}
说明
单例对象采用object 关键字声明
单例对象对应的类称之为伴生类，伴生对象的名称应该和伴生类名一致。
单例对象中的属性和方法都可以通过伴生对象名（类名）直接调用访问。
//（1）伴生对象采用object关键字声明
object Person{
var country: String = "China"
}
//（2）伴生对象对应的类称之为伴生类，伴生对象的名称应该和伴生类名一致。
class Person {
var name: String = "bobo"
}
object Test {
def main(args: Array[String]): Unit = {
//（3）伴生对象中的属性和方法都可以通过伴生对象名（类名）直接调用访问。
println(Person.country)
}
}
apply 方法
说明
(1) 通过伴生对象的 apply 方法，实现不使用 new 方法创建对象。
(2) 如果想让主构造器变成私有的，可以在()之前加上 private。
(3) apply 方法可以重载。
(4) Scala 中 obj(arg) 的语句实际是在调用该对象的 apply 方法，即 obj.apply(arg)。用以统一面向对象编程和函数式编程的风格。
(5) 当使用 new 关键字构建对象时，调用的其实是类的构造方法，当直接使用类名构建对象时，调用的其实是伴生对象的 apply 方法。
案例实操
object Test {
def main(args: Array[String]): Unit = {
// (1) 通过伴生对象的 apply 方法，实现不使用 new 关键字创建对象。
val p1 = Person()
println("p1.name=" + p1.name)
val p2 = Person("bobo")
println("p2.name=" + p2.name)
}
}
// (2) 如果想让主构造器变成私有的，可以在()之前加上 private
class private Person(private var cName: String) {
var name: String = cName
}
object Person {
def apply(): Person = {
println("apply 空参被调用")
new Person("xx")
}
def apply(name: String): Person = {
println("apply 有参被调用")
new Person(name)
}
}
//注意：也可以创建其它类型对象，并不一定是伴生类对象特质
Scala 语言中，采用特质 trait（特征）来代替接口的概念，也就是说，多个类具有相同的特质（特征）时，就可以将这个特质（特征）独立出来，采用关键字 trait 声明。
Scala 中的 trait 中即可以有抽象属性和方法，也可以有具体的属性和方法，一个类可以混入（mixin）多个特质。这种感觉类似于 Java 中的抽象类。
Scala 引入 trait 特征，第一可以替代 Java 的接口，第二个也是对单继承机制的一种补充。
声明
trait 特质名 {
trait 主体
}
特质基本语法
一个类具有某种特质（特征），就意味着这个类满足了这个特质（特征）的所有要素， 所以在使用时，也采用了extends 关键字，如果有多个特质或存在父类，那么需要采用with 关键字连接。
没有父类：class 类名 extends 特质 1 with 特质 2 with 特质 3 …
有父类：class 类名 extends 父类 with 特质 1 with 特质 2 with 特质 3… 2）
（这俩最大的区别就是extends后面是父类还是特质）
说明
类和特质的关系：使用继承的关系。
当一个类去继承特质时，第一个连接词是 extends，后面是with。
如果一个类在同时继承特质和父类时，应当把父类写在 extends 后。
特质类似于接口，但可以包含抽象方法和具体方法。
一个类可以混入多个特质。
所有的 Java 接口都可以当做Scala 特质使用
动态混入：可灵活的扩展类的功能
动态混入：创建对象时混入 trait，而无需使类混入该 trait
如果混入的 trait 中有未实现的方法，则需要实现
特质叠加
当混入的特质中有相同方法时，解决方法冲突的方式是重写该方法。
冲突分为以下两种：
第一种，一个类（Sub）混入的两个 trait（TraitA，TraitB）中具有相同的具体方法，且两个 trait 之间没有任何关系，解决这类冲突问题，直接在类（Sub）中重写冲突方法。
第二种，一个类（Sub）混入的两个 trait（TraitA，TraitB）中具有相同的具体方法，且两个 trait 继承自相同的 trait（TraitC），及所谓的“钻石问题”，解决这类冲突问题，Scala 采用了特质叠加的策略。
特质与抽象类的区别：
特质可以多重继承，而抽象类只能单继承；抽象类可以有带参数的构造函数，特质不行。
特质的应用
动态混入：通过 with 关键字动态混入特质，扩展类的功能。
依赖注入：特质可以实现简单的依赖注入功能，通过在特质中定义方法插入数据。
trait Ball {
def describe(): String = {
"ball"
}
}
trait Color extends Ball {
override def describe(): String = {
"blue-" + super.describe()
}
}
trait Category extends Ball {
override def describe(): String = {
"foot-" + super.describe()
}
}
class MyBall extends Category with Color {
override def describe(): String = {
"my ball is a " + super.describe()
}
}
object TestTrait {
def main(args: Array[String]): Unit = {
println(new MyBall().describe())
}
}
my ball is a blue-foot-ball
结论：
（1） 案例中的 super，不是表示其父特质对象，而是表示上述叠加顺序中的下一个特质，即，
MyClass 中的 super 指代 Color，Color 中的 super 指代 Category，Category 中的 super 指代 Ball。
（2） 如果想要调用某个指定的混入特质中的方法，可以增加约束： super[]，例如
super[Category].describe()。
特质与抽象类的区别：特质可以多重继承，而抽象类只能单继承；抽象类可以有带参数的构造函数，特质不行。
类型检查和转换
obj.isInstanceOf[T]：判断 obj 是不是T 类型。
obj.asInstanceOf[T]：将 obj 强转成 T 类型。
classOf 获取对象的类名。
枚举类和应用类
枚举类：需要继承 Enumeration
应用类：需要继承App
object Test {
def main(args: Array[String]): Unit = {
println(Color.RED)
}
}
// 枚举类
object Color extends Enumeration
{ val RED = Value(1, "red")
val YELLOW = Value(2, "yellow")
val BLUE = Value(3, "blue")
}
//应用类
object Test20 extends App {
println("xxxxxxxxxxx");
}Type 定义新类型
使用 type 关键字可以定义新的数据数据类型名称，本质上就是类型的一个别名
object Test {
def main(args: Array[String]): Unit = {
type S=String
var v:S="abc"
def test():S="xyz"
}
}集合
集合简介
（1）Scala 的集合有三大类：序列 Seq、集 Set、映射 Map，所有的集合都扩展自 Iterable 特质。
（2）对于几乎所有的集合类，Scala 都同时提供了可变和不可变的版本，分别位于以下两个包
不可变集合：scala.collection.immutable
可变集合：scala.collection.mutable
（3）Scala 不可变集合，就是指该集合对象不可修改，每次修改就会返回一个新对象，而不会对原对象进行修改。类似于 java 中的 String 对象
（4）可变集合，就是这个集合可以直接对原对象进行修改，而不会返回新的对象。类似于 java 中 StringBuilder 对象
建议：在操作集合的时候，不可变用符号，可变用方法
不可变集合继承图
（1）Set、Map 是 Java 中也有的集合
（2）Seq 是 Java 没有的，我们发现 List 归属到 Seq 了，因此这里的 List 就和 Java 不是同一个概念了
（3）我们前面的 for 循环有一个 1 to 3，就是 IndexedSeq 下的 Range
（4）String 也是属于 IndexedSeq
（5）我们发现经典的数据结构比如 Queue 和 Stack 被归属到 LinearSeq(线性序列)
（6）大家注意 Scala 中的 Map 体系有一个 SortedMap，说明 Scala 的 Map 可以支持排序
（7）IndexedSeq 和 LinearSeq 的区别：
（1）IndexedSeq 是通过索引来查找和定位，因此速度快，比如 String 就是一个索引集合，通过索引即可定位
（2）LinearSeq 是线型的，即有头尾的概念，这种数据结构一般是通过遍历来查找
可变集合继承图
