Scala的特质（Trait）介绍

2021-08-07 10:30:24 阅读：204 来源： 互联网

标签：特质 Scala Trait Unit student trait println def

Scala的特质（Trait）

基本概念

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…

说明

（1）类和特质的关系：使用继承的关系。
（2）当一个类去继承特质时，第一个连接词是 extends，后面是 with。
（3）如果一个类在同时继承特质和父类时，应当把父类写在 extends 后。

案例实操

（1）特质可以同时拥有抽象方法和具体方法
（2）一个类可以混入（mixin）多个特质
（3）所有的 Java 接口都可以当做 Scala 特质使用

package chapter06

object Test13_Trait {
  def main(args: Array[String]): Unit = {
    val student: Student13 = new Student13

    student.sayHello()
    student.study()
    student.dating()
    student.play()
  }



}

//定义父类
class Person13{
  val name: String = "person"
  val age: Int = 18

  def sayHello(): Unit = {
    println("hello")
  }

  def increase():Unit ={
    println("increased")
  }
}

//定义一个特质
trait Young{

  //声明一个抽象和非抽象的属性和方法

  val age: Int
  val name : String = "young"

  //定义抽象和非抽象方法
  def play(): Unit = {
    println("I can play")
  }

  def dating(): Unit
}

class Student13 extends Person13 with Young{

  //重写冲突的属性
  override val name : String = "student"


  //实现抽象方法
  override def dating(): Unit = {
    println("Student is dating")
    println(s"student : $name")
  }

  def study(): Unit = {
    println("student is study")
  }

  //重写父类方法
  override def sayHello(): Unit = {
    println("student say hello")

  }

}

特质叠加

基本概念

由于一个类可以混入（mixin）多个 trait，且 trait 中可以有具体的属性和方法，若混入的特质中具有相同的方法（方法名，参数列表，返回值均相同），必然会出现继承冲突问题。
冲突分为以下两种：
第一种，一个类（Sub）混入的两个 trait（TraitA，TraitB）中具有相同的具体方法，且
两个 trait 之间没有任何关系，解决这类冲突问题，直接在类（Sub）中重写冲突方法。
在这里插入图片描述
第二种，一个类（Sub）混入的两个 trait（TraitA，TraitB）中具有相同的具体方法，且
两个 trait 继承自相同的 trait（TraitC），及所谓的“钻石问题”，解决这类冲突问题，Scala
采用了特质叠加的策略。

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

案例实操

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

动态混入：创建对象时混入 trait，而无需使类混入该 trait
如果混入的 trait 中有未实现的方法，则需要实现

package chapter06

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

    val student = new Student14

    student.study()
    student.increase()

    student.play()
    student.increase()

    student.dating()
    student.increase()

    println("==========================")

    //特质动态混入
    val studentWithTalent = new Student14 with Talent {

      override def singing(): Unit = {
        println("student is good at singing")
      }
    }

    studentWithTalent.play()
    studentWithTalent.dating()
    studentWithTalent.study()
    studentWithTalent.singing()


  }

}

//再定义一个特质
trait Knowledge{

  var amount : Int = 0
  def increase(): Unit
}

//再再来一个特质
trait Talent{
  def singing(): Unit

}

class Student14 extends Person13 with Young with Knowledge {

  //重写冲突的属性
  override val name : String = "student"


  //实现抽象方法
  override def dating(): Unit = {
    println("Student is dating")
    println(s"student : $name")
  }

  def study(): Unit = {
    println("student is study")
  }

  //重写父类方法
  override def sayHello(): Unit = {
    println("student say hello")

  }

  //实现特质的抽象方法
  override def increase(): Unit = {
    amount += 1

    println(s"student $name knowledge increased: $amount")

  }

}

特质叠加执行顺序

当一个类混入多个特质的时候，scala 会对所有的特质及其父特质按照一定的顺序进行
排序

案例说明

package chapter06

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

      println(new MyBall().describe()) 


  }

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

而此案例中的 super.describe()调用的实际上是排好序后的下一个特质中的 describe()
方法，排序规则如下：
在这里插入图片描述

第一步∶列出混入的第一个特质(Category )的继承关系，作为临时叠加顺序

第二步∶列出混入的第二个特质(Color )的继承关系，并将该顺序叠加到临时顺序前边，已经出现的特质不再重复
在这里插入图片描述

第三步:将子类(MyBall )放在临时叠加顺序的第一个，得到最终的叠加顺序

结论：
（1）案例中的 super，不是表示其父特质对象，而是表示上述叠加顺序中的下一个特质，
即，MyClass 中的 super 指代 Color，Color 中的 super 指代 Category，Category 中的 super指代 Ball。
（2）如果想要调用某个指定的混入特质中的方法，可以增加约束：super[ ]，例如super[Category].describe()。

特质自身类型

说明

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

案例实操

package chapter06

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

    val user = new RegisterUser("alice","password123")

    user.insert

  }

}

//用户类
class User(val name: String, val password: String)

//数据库操作类
trait UserDao{
  _: User =>

  //向数据库插入数据
  def insert: Unit = {

    println(s"insert into db: ${this.name}")

  }
}

//注册用户类
class RegisterUser(name: String, password: String) extends User(name,password) with UserDao {

  println("注册了一个用户")

}

特质和抽象类的区别

优先使用特质。一个类扩展多个特质是很方便的，但却只能扩展一个抽象类。
如果你需要构造函数参数，使用抽象类。因为抽象类可以定义带参数的构造函数，而特质不行（有无参构造）。

标签：特质,Scala,Trait,Unit,student,trait,println,def
来源： https://blog.csdn.net/weixin_44480968/article/details/119477481

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

Scala的特质（Trait）介绍