scala特质对比java的接口使用方法

6.7 特质（Trait）

Scala语言中，采用特质trait（特征）来代替接口的概念，也就是说，多个类具有相同的特质（特征）时，就可以将这个特质（特征）独立出来，采用关键字trait声明。

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

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

6.7.1 特质声明

1）基本语法

trait 特质名 {

trait主体

}

2）案例实操

trait Age13 {

// 允许出现抽象的属性和方法

val age :Int

def sayHi():Unit

// 允许出现非抽象的属性

val age1:Int = 10

def sayHi1()={

println("hi ")

}

通过查看字节码，可以看到特质=抽象类+接口

6.7.2 特质基本语法

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

1）基本语法：

没有父类：class 类名 extends 特质1 with 特质2 with 特质3 …

有父类：class 类名 extends 父类 with 特质1 with 特质2 with 特质3…

2）说明

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

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

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

3）案例实操

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

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

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

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

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

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

object Test14_TraitMixin {

def main(args: Array[String]): Unit = {

val student1 = new Student14

println(student1.name1)

println(student1.age1)

println(student1.name)

println(student1.age)

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

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

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

// 只有当前创建的一个对象具有混入的特质类是没有的

val teacher1: Teacher14 with Age14 = new Teacher14 with Age14 {

override val name = "teacher"

override var age = 18

}

trait Age14{

val name:String

var age:Int

val name1:String = "age"

var age1:Int = 10

}

abstract class Person14{

val name:String = "person"

var age:Int = 18

val name1:String = "person1"

// var age1:Int = 11

}

// 继承的时候父类和特质不能有相同的具体属性会发生冲突报错

// 报错的如果是val 常量可以通过重写解决如果是var 变量只能去修改父类或者特质

// 如果继承的属性一个是抽象的一个是非抽象的不会发生冲突需要注意var的属性不能重写

class Student14 extends Person14 with Age14{

override val name: String = "student"

age = 19

// 通过重写解决

override val name1: String = "student"

age1 = 18

}

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

class Teacher14 extends java.io.Serializable{

}

6.7.3 特质叠加

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

第一种，一个类（Sub）混入的两个trait（TraitA，TraitB）中具有相同的具体方法，且两个trait之间没有任何关系，解决这类冲突问题，直接在类（Sub）中重写冲突方法。

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

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

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())

}

结果如下：

6.7.4 特质叠加执行顺序

思考：上述案例中的super.describe()调用的是父trait中的方法吗？

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

结论：

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

（2）如果想要调用某个指定的混入特质中的方法，可以增加约束：super[]，例如super[Category].describe()。

6.7.5 特质自身类型

1）说明

自身类型可实现依赖注入的功能。

2）案例实操

object Test16_TypeSelf {

def main(args: Array[String]): Unit = {

// val young1: Young16 = new Young16 {

// override val age: Int = 16

// }

}

trait Age16 {

val age: Int

}

//trait Young16 extends Age16

trait Young16 {

// 特质自身类型

_: Age16 =>

}

// 特质自身类型要求必须同时实现两个依赖的特质

class Person16 extends Young16 with Age16{

override val age: Int = 17

}

6.7.6特质和抽象类的区别

1.优先使用特质。一个类扩展多个特质是很方便的，但却只能扩展一个抽象类。

2.如果你需要构造函数参数，使用抽象类。因为抽象类可以定义带参数的构造函数，而特质不行（有无参构造）。

6.8 扩展

6.8.1 类型检查和转换

1）说明

（1）obj.isInstanceOf[T]：判断obj是不是T类型。

（2）obj.asInstanceOf[T]：将obj强转成T类型。

（3）classOf获取类模板。

2）案例实操

class Person{

}

object Person {

def main(args: Array[String]): Unit = {

val person = new Person

//（1）判断对象是否为某个类型的实例

val bool: Boolean = person.isInstanceOf[Person]

if ( bool ) {

//（2）将对象转换为某个类型的实例

val p1: Person = person.asInstanceOf[Person]

println(p1)

}

//（3）获取类的模板

val pClass: Class[Person] = classOf[Person]

println(pClass)

}

6.8.2 枚举类和应用类

1）说明

枚举类：需要继承Enumeration

应用类：需要继承App

2）案例实操

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");
}

6.8.3 Type定义新类型

1）说明

使用type关键字可以定义新的数据数据类型名称，本质上就是类型的一个别名

2）案例实操

object Test {

def main(args: Array[String]): Unit = {

        type S=String
        var v:S="abc"
        def test():S="xyz"
    }
}