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