9 scala的类继承及trait

1 class 继承

为了提高代码的重用性，提高开发效率，scala 的 class 是支持继承的。

Scala 的继承与 Java 的继承非常类似：

(1) 单继承：

类似于 Java，Scala 也只支持单继承，一个类只能直接继承自一个父类。这意味着一个 Scala 类可以拥有一个直接的父类，就像 Java 中一样。

(2) 继承语法：

Scala 的继承语法类似于 Java，使用 extends 关键字来继承一个父类。例如：

class ChildClass extends ParentClass {
  // 子类的定义
}

(3) 重写方法：

Scala 和 Java 都允许子类覆盖父类中的方法，通过使用 override 关键字来标记。例如：

class ChildClass extends ParentClass {
  override def someMethod(): Unit = {
    // 子类重写父类的方法
  }
}

(4) 调用父类方法：

在 Scala 中，使用 super 关键字来调用父类的方法。例如：

class ChildClass extends ParentClass {
  override def someMethod(): Unit = {
    super.someMethod() // 调用父类的方法
    // 子类的其他逻辑
  }
}

下面定义了足球员类 FootballPlayer，及它的子类，进攻球员类 Striker，防守球员类 Defender:

/**
 * 足球员父类
 *
 * @param name 球员姓名
 */
class FootballPlayer(val name: String) {
  def play(): String = "Playing football"
}

/**
 * 进攻球员子类
 *
 * @param name 球员姓名
 */
class Striker(name: String) extends FootballPlayer(name) {
  override def play(): String = "Scoring goals" // 重写父类的 play 方法

  def celebrate(): String = s"$name is celebrating"
}

/**
 * 防守球员子类
 * @param name 球员姓名
 */
class Defender(name: String) extends FootballPlayer(name) {
  override def play(): String = "Defending the goal" // 重写父类的 play 方法
  def tackle(): String = s"$name is making a tackle"
}

object App {
  def main(args: Array[String]): Unit = {
    // 测试
    val striker = new Striker("Ronaldo")
    println(striker.play()) // 输出 Scoring goals，调用重写后的 play 方法
    println(striker.celebrate()) // 输出 Ronaldo is celebrating，调用子类的 celebrate 方法

    val defender = new Defender("Sergio Ramos")
    println(defender.play()) // 输出 Defending the goal，调用重写后的 play 方法
    println(defender.tackle()) // 输出 Sergio Ramos is making a tackle，调用子类的 tackle 方法
  }
}

运行程序，控制台输出：

Scoring goals
Ronaldo is celebrating
Defending the goal
Sergio Ramos is making a tackle

2 抽象类

在 Scala 中，抽象类是一种不能被实例化的类，它们通常用于定义一些通用的行为，但又需要子类来提供具体实现的情况。

/**
 * 足球员抽象类
 * @param name 球员姓名
 */
abstract class FootballPlayer(val name: String) {
  /**
   * 抽象方法，没有具体实现
   * @return
   */
  def play(): String
}

/**
 * 定义实现类 Striker 继承自抽象类 FootballPlayer
 * @param name 球员姓名
 */
class Striker(name: String) extends FootballPlayer(name) {
  // 实现抽象方法 play
  def play(): String = s"$name is scoring goals"
}

/**
 * 定义实现类 Defender 继承自抽象类 FootballPlayer
 * @param name 球员姓名
 */
class Defender(name: String) extends FootballPlayer(name) {
  // 实现抽象方法 play
  def play(): String = s"$name is defending the goal"
}

object App {
  def main(args: Array[String]): Unit = {
    // 定义进攻球员对象
    val striker = new Striker("Ronaldo")
    println(striker.play()) // 输出 Ronaldo is scoring goals

    // 定义防守球员对象
    val defender = new Defender("Sergio Ramos")
    println(defender.play()) // 输出 Sergio Ramos is defending the goal
  }
}

上面的例子中：

• FootballPlayer 类是一个抽象类，包含一个抽象方法 play，没有具体的实现。
• Striker 类和 Defender 类是抽象类 FootballPlayer 的实现类，它们都实现了 play 方法，并提供了具体的实现。
• 在测试部分，创建了一个 Striker 对象和一个 Defender 对象，并分别调用它们的 play 方法。

运行代码，控制台输出：

Ronaldo is scoring goals
Sergio Ramos is defending the goal

3 特质

3.1 特质介绍

Trait（特质）是 Scala 中一种非常有用的机制，可以用于定义对象的特定特征或行为。Trait类似于 Java 中的接口。

Trait 与 抽象类 是不同的：

• Trait 可以被多重继承，一个类可以扩展多个 Trait，但只能继承一个抽象类。
• Trait 不能接受构造参数，但抽象类可以。
• Trait 与 抽象类 的语义不同，Trait 更适合描述对象的特征或行为，以及对象之间的 has-a 或 can-do 关系。抽象类更适合描述 is-a 关系，即子类是父类的一种特定类型。

下面是一个使用特质的例子：

/**
 * 定义一个球员类
 *
 * @param name 球员姓名
 */
class FootballPlayer(val name: String)

/**
 * 声明一个奔跑 trait
 */
trait Runner {
  def run(name: String): String = s"${name} is running"
}

/**
 * 声明一个得分手 trait
 */
trait Scorer {
  def score(name: String): String = s"${name} is scoring goals"
}

/**
 * 声明一个防守人员 trait
 */
trait Defender {
  def defend(name: String): String = s"${name} is defending"
}

/**
 * 创建实现类，同时继承三个 Trait
 *
 * @param name 球员姓名
 */
class Player(name: String) extends FootballPlayer(name) with Runner with Scorer with Defender

object App {
  def main(args: Array[String]): Unit = {
    // 测试
    val player = new Player("Messi")
    // 输出 Player is running
    println(player.run(player.name))
    // 输出 Player is scoring goals
    println(player.score(player.name))
    // 输出 Player is defending
    println(player.defend(player.name))
  }
}

上面的例子中：

• 定义了一个 FootballPlayer 类，它具有一个 name 属性，用于表示足球球员的姓名。
• Runner Trait 包含一个 run 方法，表示球员奔跑的行为。
• Scorer Trait 包含一个 score 方法，表示球员进球的行为。
• Defender Trait 包含一个 defend 方法，表示球员防守的行为。
• 创建了一个名为 Player 的实现类，它继承了 FootballPlayer 类，并且同时混入了 Runner、Scorer 和 Defender 三个 Trait。
• 在测试部分，创建了一个名为 player 的 Player 实例，并调用了它的 run、score 和 defend 方法，展示了实现类获得了这三个 Trait 中定义的行为。

3.2 对象混入特质

在 Scala 中，对象混入（Mixins）Trait 是一种非常强大和灵活的特性，它允许对象在运行时获得 Trait 中定义的行为，而无需继承 Trait 的类。对象混入 Trait 的过程就是 将 Trait 中定义的方法和属性动态地添加到对象中。

混入 Trait 可以为对象提供额外的功能，而无需改变其类层次结构。这种灵活性使得在 Scala 中，对象可以非常容易地适应不同的需求，同时保持代码的简洁和可维护性。

/**
 * 定义队长特质
 */
trait Captain {
  /**
   * 标识是否为队长
   */
  var isCaptain: Boolean = false

  /**
   * 判断 isCaption，输出是否为队长
   */
  def hello(): Unit = {
    if (isCaptain) println("I am caption") else println("I am not caption")
  }
}

/**
 * 球员类
 * @param name 球员姓名
 */
class FootballPlayer(val name: String)

object App {
  def main(args: Array[String]): Unit = {
    // 实例化 FootballPlayer 时，让对象同时拥有 Captain 的相关属性、方法
    val player = new FootballPlayer("Ronaldo") with Captain
    player.isCaptain = true
    player.hello()
  }
}

在这个例子中，使用 对象混入特质 的方式，给 FootballPlayer 对象添加了队长属性。这使得我们可以非常灵活地为对象添加额外的功能，而无需修改类的层次结构。