9 scala的类继承及trait

本文主要是介绍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) {// 实现抽象方法 playdef play(): String = s"$name is scoring goals"
}/*** 定义实现类 Defender 继承自抽象类 FootballPlayer* @param name 球员姓名*/
class Defender(name: String) extends FootballPlayer(name) {// 实现抽象方法 playdef 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 Defenderobject App {def main(args: Array[String]): Unit = {// 测试val player = new Player("Messi")// 输出 Player is runningprintln(player.run(player.name))// 输出 Player is scoring goalsprintln(player.score(player.name))// 输出 Player is defendingprintln(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 Captainplayer.isCaptain = trueplayer.hello()}
}