一.定义类

基本语法：

1.2属性

1.3 封装

1.4 访问权限

1.5创建对象

1.6构造器

1.7继承和多态

多态

1.8抽象类

1.9匿名子类

1.10单例对象（伴生对象）

1.11 apply方法

1.12特质（Trait）

1.13使用特质的基本语法

1.14特质叠加

特质和抽象类的区别

类：可以看作一个模板

对象：表示具体的事物

一.定义类

回顾java，如果类时public的，则必须和文件名一致，一般一个java有一个public类

注意：Scala 中没有 public，一个.scala 中可以写多个类。

基本语法：

说明：Scala 语法中，类并不声明为 public，所有这些类都具有公有可见性（即默认就是 public），一个Scala源文件可以包含多个类

1.2属性

属性是类的一个组成部分

基本语法：

注：Bean 属性（@BeanPropetry），可以自动生成规范的 setXxx/getXxx 方法

实例：

1.3 封装

封装就是把抽象出的数据和对数据的操作封装在一起，数据被保护在内部，程序的其它部分只有通过被授权的操作（成员方法），才能对数据进行操作。Java 封装操作如下

（1）将属性进行私有化

（2）提供一个公共的 set 方法，用于对属性赋值

（3）提供一个公共的 get 方法，用于获取属性的值

Java的封装：私有化，提供getter和setter方法

Scala 中的 public 属性，底层实际为 private，并通过 get 方法（obj.field()）和 set 方法（obj.field_=(value)）对其进行操作。所以 Scala 并不推荐将属性设为 private，再为其设置 public 的 get 和 set 方法的做法。但由于很多 Java 框架都利用反射调用 getXXX 和 setXXX 方法，有时候为了和这些框架兼容，也会为 Scala 的属性设置 getXXX 和 setXXX 方法（通过 @BeanProperty 注解实现）。

1.4 访问权限

在 Java 中，访问权限分为：public，private，protected 和默认包访问权限。

在 Scala 中，你可以通过类似的修饰符达到同样的效果。但是使用上有区别。

（1）Scala 中属性和方法的默认访问权限为 public，但 Scala 中无 public 关键字。

（2）private 为私有权限，只在类的内部和伴生对象中可用。

（3）protected 为受保护权限，Scala 中受保护权限比 Java 中更严格，同类、子类可以访问，同包无法访问。

（4）private[包名]增加包访问权限，包名下的其他类也可以使用

实例：

1.5创建对象

基本语法：

注意点：

val修饰对象，不可以改变对象的引用，可以改变对象属性的值

var修饰对象，可以修改对象的引用和修改对象的属性值

自动推导变量类型不能够多态，所以多态需要显示声明

实例：val修改属性的值

1.6构造器

scala类对的构造器包括：主构造器和辅助构造器

基本语法：

（1）辅助构造器，函数的名称 this，可以有多个，编译器通过参数的个数及类型来区

分。

（2）辅助构造方法不能直接构建对象，必须直接或者间接调用主构造方法。

（3）构造器调用其他另外的构造器，要求被调用构造器必须提前声明。

实例：

构造器参数：

Scala 类的主构造器函数的形参包括三种类型：未用任何修饰、var 修饰、val 修饰

（1）未用任何修饰符修饰，这个参数就是一个局部变量，此时在类内都可以访问到这个变量。逻辑上不是一个成员（报错信息这么写），但是可以访问，WTF？？？

（2）var 修饰参数，作为类的成员属性使用，可以修改

（3）val 修饰参数，作为类只读属性使用，不能修改

（4）主构造器中的var val成员也可以添加访问修饰符。主构造器的访问修饰符添加到参数列表()前。

1.7继承和多态

继承基本语法：

子类继承父类属性和方法。

可以调用父类构造器，但感觉好像很局限，子类中只可能调用到主构造或者辅助构造中的

其中一个构造器。

继承的调用顺序：父类构造器->子类构造器

实例：

多态

java中属性静态绑定，根据变量的引用类型确定，方法是动态绑定。

但scala中属性和方法都是动态绑定。就属性而言，其实也不应该在子类和父类中定义同名字段。

同java一样，所有实例方法都是虚方法，都可以被子类覆写。

override关键字覆写。

scala中属性（字段）也可以被重写，加override关键字。

案例：对比java和scala的重写

1.8抽象类

基本语法:

（1）定义抽象类：abstract class Person{} //通过 abstract 关键字标记抽象类

（2）定义抽象属性：val|var name:String //一个属性没有初始化，就是抽象属性

（3）定义抽象方法：def hello():String //只声明而没有实现的方法，就是抽象方法

抽象属性：val/var name: Type，不给定初始值。
抽象方法：def methodName(): RetType，只声明不实现。
子类如果没有覆写全部父类未定义的属性和方法，那么就必须定义为抽象类。老生常谈了。
重写非抽象方法属性必须加override，重写抽象方法则可以不加override。
子类调用父类中方法使用super关键字。
子类重写父类抽象属性，父类抽象属性可以用var修饰，val var都可以。因为父类没有实现嘛，需要到子类中来实现。
如果是重写非抽象属性，则父类非抽象属性只支持val，不支持var。因为var修饰为可变量，子类继承后可以直接使用修改，没有必要重写。val不可变才有必要重写。
实践建议是重写就加override，都是很自然的东西，理解就好，不必纠结于每一个细节。

1.9匿名子类

匿名子类，一般都是在运行时期间定义的类，匿名的意思，就是没有名字的类，可不是class后面跟的类名。

我们有时候需要添加一些类，去临时实现一些问题或添加一些功能，为了避免在项目里添加java文件，尤其是仅使用一次这个类的时候，我们就会使用匿名类

scala的匿名子类和java一样，可以通过包含带定义或者重写的代码块的方式创建一个匿名子类

实例：

1.10单例对象（伴生对象）

Scala语言是完全面向对象的语言，所以并没有静态的操作（即在Scala中没有静态的概念）。但是为了能够和Java语言交互（因为Java中有静态概念），就产生了一种特殊的对象来模拟类对象，该对象为单例对象。若单例对象名与类名一致，则称该单例对象这个类的伴生对象，这个类的所有“静态”内容都可以放置在它的伴生对象中声明。

基本语法：

（1）单例对象采用 object 关键字声明

（2）单例对象对应的类称之为伴生类，伴生对象的名称应该和伴生类名一致。

（3）单例对象中的属性和方法都可以通过伴生对象名（类名）直接调用访问。

实例：

取代static语义。
编译后其实会生成两个类，伴生对象是伴生类（类名为对应类后加$符号）的单例对象。
obejct，名称和类一致，必须放同一个文件，前面已经说过了。
常见用法：构造器私有化，用伴生对象中的工厂方法。和静态工厂方法使用起来也没有什么区别。
伴生对象实现apply方法后调用时可以省略.apply，直接使用className(args)。库中很多这种用法创建实例，是一个语法糖。
测试伴生对象时就在该对象内定义main函数编译时会出现的奇怪的访问权限问题。可能对包含入口的伴生对象做了特殊处理，具体细节尚不清楚。最好将main定义在单独的伴生对象内。

1.11 apply方法

（1）通过伴生对象的 apply 方法，实现不使用 new 方法创建对象。

（2）如果想让主构造器变成私有的，可以在()之前加上 private。

（3）apply 方法可以重载。

（4）Scala 中 obj(arg)的语句实际是在调用该对象的 apply 方法，即 obj.apply(arg)。用以统一面向对象编程和函数式编程的风格。

（5）当使用 new 关键字构建对象时，调用的其实是类的构造方法，当直接使用类名构建对象时，调用的其实时伴生对象的 apply 方法。

案例：

注意：也可以创建其他类型的对象，并不一定是需要伴生类对象

1.12特质（Trait）

Scala 语言中，采用特质 trait（特征）来代替接口的概念，也就是说，多个类具有相同的

特质（特征）时，就可以将这个特质（特征）独立出来，采用关键字 trait 声明。

Scala 中的 trait 中即可以有抽象属性和方法，也可以有具体的属性和方法，一个类可以混入（mixin）多个特质。这种感觉类似于 Java 中的抽象类。

Scala 引入 trait 特征，第一可以替代 Java 的接口，第二个也是对单继承机制的一种补充

基本语法：

案例：

1.13使用特质的基本语法

一个类具有某种特质（特征），就意味着这个类满足了这个特质（特征）的所有要素，所以在使用时，也采用了 extends 关键字，如果有多个特质或存在父类，那么需要采用 with

关键字连接。

基本语法

（1）类和特质的关系：使用继承的关系。

（2）当一个类去继承特质时，第一个连接词是 extends，后面是 with。

（3）如果一个类在同时继承特质和父类时，应当把父类写在 extends 后。

（4）匿名子类也可以引入特质

（5）可以定义抽象和非抽象的属性和方法。

案例：

（1）特质可以同时拥有抽象方法和具体方法

（2）一个类可以混入（mixin）多个特质

（3）所有的 Java 接口都可以当做 Scala 特质使用

（4）动态混入：可灵活的扩展类的功能

（4.1）动态混入：创建对象时混入 trait，而无需使类混入该 trait

（4.2）如果混入的 trait 中有未实现的方法，则需要实现

1.14特质叠加

由于一个类可以混入（mixin）多个 trait，且 trait 中可以有具体的属性和方法，若混入的特质中具有相同的方法（方法名，参数列表，返回值均相同），必然会出现继承冲突问

题。冲突分为以下两种：

第一种，一个类（Sub）混入的两个 trait（TraitA，TraitB）中具有相同的具体方法，且两

个 trait 之间没有任何关系，解决这类冲突问题，直接在类（Sub）中重写冲突方法。

第二种，一个类（Sub）混入的两个 trait（TraitA，TraitB）中具有相同的具体方法，且两个 trait 继承自相同的 trait（TraitC），及所谓的“钻石问题”，解决这类冲突问题，Scala 采

用了特质叠加的策略。

所谓的特质叠加，就是将混入的多个 trait 中的冲突方法叠加起来

案例：

特质叠加执行的顺序：
当一个类混入多个特质的时候，scala 会对所有的特质及其父特质按照一定的顺序进行排序，而此案例中的 super.describe()调用的实际上是排好序后的下一个特质中的 describe() 方法。，排序规则如下：

案例中的 super，不是表示其父特质对象，而是表示上述叠加顺序中的下一个特质，即，MyClass 中的 super 指代 Color，Color 中的 super 指代 Category，Category 中的 super 指代 Ball。

如果想要调用某个指定的混入特质中的方法，可以增加约束：super[]

解决特质菱形继承方式的解决办法：转换为线性的继承链条，在前面的为基类，在后面的为子类

（1）特征和基类或者多个特征中重名的属性或方法需要在子类中覆写以解决冲突，最后因为动态绑定，所有使用的地方都是子类的字段或方法。属性的话需要类型一致，不然提示不兼容。方法的话参数列表不一致会视为重载而不是冲突。

（2）如果基类和特征中的属性或方法一个是抽象的，一个非抽象，且兼容，那么可以不覆写。很直观，就是不能冲突不能二义就行。

（3）多个特征和基类定义了同名方法的，就需要在子类重写解决冲突。其中可以调用父类和特征的方法，此时super.methodName指代按照顺序最后一个拥有该方法定义的特征或基类。也可以用super[baseClassOrTraitName].methodName直接指代某个基类的方法，注意需要是直接基类，间接基类则不行。也就是说基类和特征基本是同等地位。