Scala - 继承

本章将讨论 Scala 编程中的继承。您可以从另一个 class 继承属性和方法，从而实现代码复用并创建层次化的 class 结构。

继承

继承是面向对象编程中的基本概念。您可以从现有 class（superclass）继承新 class（subclass）的字段和方法。被继承的 class 称为 superclass，继承的 class 称为 subclass。subclass 还可以重写继承的方法，并定义新方法和字段。

一个 class 可以获取另一个 class 的属性（字段）和方法，从而实现代码复用并创建 class 之间的层次关系。

语法

Scala 中继承的语法如下 -

class Superclass {
   // superclass definition
}

class Subclass extends Superclass {
   // subclass definition
}

示例

以下示例展示了 Scala 编程中的基本继承 -

class Animal {
   def eat(): Unit = {
      println("Animal is eating")
   }
}

class Dog extends Animal {
   def bark(): Unit = {
      println("Dog is barking")
   }
}

object Demo {
   def main(args: Array[String]): Unit = {
      val dog = new Dog()
      dog.eat() // Inherited method
      dog.bark() // Subclass method
   }
}

将上述程序保存为 Demo.scala。使用以下命令编译并执行该程序。

命令

> scalac Demo.scala
> scala Demo

输出

Animal is eating
Dog is barking

在示例中，Dog class 扩展了 Animal class，继承了其 eat 方法。Dog class 还定义了自己的 bark 方法。Demo object 创建了 Dog 的实例，并调用了继承的方法和 subclass 方法。

方法重写

subclass 可以重写 superclass 中定义的方法。使用 override 关键字来指示方法被重写。

语法

Scala 中重写的语法如下 -

class Superclass {
   def method(): Unit = {
      // superclass method
   }
}

class Subclass extends Superclass {
   override def method(): Unit = {
      // subclass method
   }
}

示例

以下示例展示了 Scala 编程中的方法重写 -

class Animal {
   def sound(): Unit = {
      println("Animal sound")
   }
}

class Dog extends Animal {
   override def sound(): Unit = {
      println("Dog Bark")
   }
}

object Demo {
   def main(args: Array[String]): Unit = {
      val animal: Animal = new Dog()
      animal.sound() // Calls the overridden method in Dog
   }
}

将上述程序保存为 Demo.scala。使用以下命令编译并执行该程序。

命令

> scalac Demo.scala
> scala Demo

输出

Dog Bark

在示例中，Dog class 重写了 Animal class 的 sound 方法。Demo object 通过 Animal 类型的引用展示了多态，调用了 Dog class 中重写的方法。

使用 super 关键字的继承

Scala 中的 super 关键字用于在子类中调用父类中定义的 method 或 constructor。

语法

在子类中使用 super 关键字调用 method 的语法如下 -

class Superclass {
   def method(): Unit = {
     // 父类方法
   }
}

class Subclass extends Superclass {
   override def method(): Unit = {
      super.method() // 调用父类方法
      // 子类额外逻辑
   }
}

示例

以下示例展示了在 Scala 编程中使用 super 关键字 -

class Animal {
   def sound(): Unit = {
      println("Animal sound")
   }
}

class Dog extends Animal {
   override def sound(): Unit = {
      super.sound()
      println("Dog barks")
   }
}

object Demo {
   def main(args: Array[String]): Unit = {
      val dog = new Dog
      dog.sound()
   }
}

将上述程序保存为 Demo.scala。使用以下命令编译和执行该程序。

命令

> scalac Demo.scala
> scala Demo

输出

Animal sound
Dog barks

在示例中，Dog 类使用 super 关键字调用 Animal 类的 sound 方法。它在添加自己的实现之前调用。Demo 对象创建 Dog 类的实例并调用被覆盖的 sound 方法。

构造函数继承

构造函数不会被继承。相反，子类可以使用 extends 关键字调用父类构造函数。

语法

构造函数继承的语法如下 -

class Superclass(val param: Type) {
   // 父类定义
}

class Subclass(param: Type) extends Superclass(param) {
   // 子类定义
}

示例

以下示例展示了 Scala 中的构造函数继承 -

class Animal(val name: String) {
   def display(): Unit = {
      println(s"Animal: $name")
   }
}

class Dog(name: String, val breed: String) extends Animal(name) {
   def displayBreed(): Unit = {
      println(s"Breed: $breed")
   }
}

object Demo {
   def main(args: Array[String]): Unit = {
      val dog = new Dog("Buddy", "Golden Retriever")
      dog.display() // 调用 Animal 的 display 方法
      dog.displayBreed() // 调用 Dog 的 displayBreed 方法
   }
}

将上述程序保存为 Demo.scala。使用以下命令编译和执行该程序。

命令

> scalac Demo.scala
> scala Demo

输出

Animal: Buddy
Breed: Golden Retriever

在示例中，Dog 类继承自 Animal 类。它使用 extends 关键字调用 Animal 构造函数。Demo 对象创建 Dog 的实例并调用继承的 display 方法和子类的 displayBreed 方法。

抽象类

Scala 中的抽象类不能被实例化。它包含抽象方法（没有实现的方法）和具体方法（有实现的方法）。子类必须为抽象方法提供实现。

语法

抽象类的语法如下 -

abstract class Superclass {
   def abstractMethod(): Unit // 抽象方法
}

class Subclass extends Superclass {
   def abstractMethod(): Unit = {
      // 方法实现
   }
}

示例

以下示例展示了 Scala 中的抽象类和方法。

abstract class Animal {
   def sound(): Unit
}

class Dog extends Animal {
   def sound(): Unit = {
      println("Dog barks")
   }
}

object Demo {
   def main(args: Array[String]): Unit = {
      val dog = new Dog
      dog.sound()
   }
}

将上述程序保存为 Demo.scala。使用以下命令编译和执行该程序。

命令

> scalac Demo.scala
> scala Demo

输出

Dog barks

在示例中，Animal 类是抽象类。它定义了一个抽象方法 sound。Dog 类继承自 Animal 类并为 sound 方法提供了实现。Demo 对象创建 Dog 类的实例并调用已实现的 sound 方法。

Traits

Scala 中的 Traits 类似于 Java 中的接口。Traits 可以包含抽象方法和具体方法。一个 class 可以扩展多个 traits。因此，你可以实现多重继承。

Syntax

Traits 的语法如下 -

trait TraitName {
   def abstractMethod(): ReturnType
   def concreteMethod(): ReturnType = {
      // 实现
   }
}

class ClassName extends TraitName {
   // 抽象方法的实现
}

Example

以下示例展示了在 Scala 编程中使用 traits -

trait Animal {
   def sound(): Unit
}

trait Pet {
   def play(): Unit = {
      println("Pet is playing")
   }
}

class Dog extends Animal with Pet {
   def sound(): Unit = {
      println("Dog barks")
   }
}

object Demo {
   def main(args: Array[String]): Unit = {
      val dog = new Dog
      dog.sound()
      dog.play()
   }
}

将上述程序保存为 Demo.scala。使用以下命令编译并执行该程序。

Command

> scalac Demo.scala
> scala Demo

Output

Dog barks
Pet is playing

在示例中，Dog class 同时扩展了 Animal trait 和 Pet trait。Demo object 创建 Dog class 的一个实例，并调用两个 traits 中的方法。

Inheritance Summary

• 你可以从现有 class（superclass）继承新 class（subclass）的字段和方法。因此，可以实现代码复用。
• subclass 可以使用 override 关键字重写 superclass 中的方法。
• super 关键字用于调用 superclass 中的方法和构造函数。
• Scala 中的 abstract class 可以包含抽象方法和具体方法，并且不能被实例化。
• 你可以使用 Traits 在 Scala 中实现多重继承。因此，一个 class 可以扩展多个 traits。