Scala学习笔记9: 继承

于 2024-06-05 15:27:36 发布
阅读量790 收藏 16
点赞数 12
分类专栏： 语言 大数据 文章标签： scala 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/taerge0110/article/details/139473640
版权

目录

第九章 继承

在Scala中, 继承(Inheritance) 是面向对象编程的重要概念, 允许一个类 (子类) 继承另一个类 (父类) 的特性和行为 ;

Scala中的继承通过 extends 关键字实现;

子类可以继承父类的字段、方法和特制 (traits) , 并可以重写父类的方法 .

1- 扩展类和重写方法

在Scala中, 扩展类 (Extending Classes) 是通过使用 extends 关键字来实现的 ;

当一个类扩展另一个类时, 他会继承父类的特性 (字段, 方法等) 并可以重写父类的方法 ;

当子类继承父类并重写的方法是, 需要使用 override 关键字来标记重写的方法 ;

示例:

  // 定义父类
  class Animal {
    def sound(): Unit = {
      println("Animal makes a sound !")
    }
  }

  // 定义子类, 扩展自 Animal
  class Dog extends Animal {
    override def sound(): Unit = {
      println("Dog barks !")
    }
  }


  def main(args: Array[String]): Unit = {
    // 创建子类对象
    val dog = new Dog()
    // 调用子类方法
    dog.sound() // 输出: Dog barks !
  }
  • 在上面的示例中, Dog 类扩展自 Animal 类, 并重写了 sound() 方法 ;
  • 通过扩展类, Dog 类继承了 Animal 类的特性, 并可以根据需要进行定制化 ;
  • 这种灵活性使得Scala中的继承和重写方法非常强大 ;

需要注意的是, 在Scala中, 一个类只能扩展一个类(单继承) , 到那时可以混入多个特质(traits) 来实现多重继承和代码复用 .

2- 类型转换和检查

在Scala中, 继承中的类型转换和检查可以通过 isInstanceOf 和 asInstanceOf 方法来实现 ;

示例:

  // 定义父类
  class Animal {
    def sound(): Unit = {
      println("Animal makes a sound !")
    }
  }

  // 定义子类, 扩展自 Animal
  class Dog extends Animal {
    def bark(): Unit = {
      println("Dog barks !")
    }
  }


  def main(args: Array[String]): Unit = {
    // 创建子类实例
    val animal: Animal = new Dog()

    // 类型检查
    if (animal.isInstanceOf[Dog]) {
      // 类型转换
      val dog: Dog = animal.asInstanceOf[Dog]
      dog.bark() // 输出: Dog barks !
    } else {
      println("Not a Dog !")
    }

  }
  • 在上面的示例中, 我们首先创建了一个 Dog 类的实例, 并将其赋值给一个 Animal 类型的变量 ;
  • 然后, 我们使用 isInstanceOf 方法检查变量的类型是否是 Dog , 如果是, 则使用 asInstanceOf 方法将其转换为 Dog 类型, 并调用 bark() 方法 ;
  • 如果类型不是 Dog , 则输出 “Not a Dog !”

需要注意的是, 在进行类型转换时, 应该谨慎处理可能出现的类型不匹配情况, 避免抛出 ClassCastException 异常 ;

因此, 在进行类型转换之前最好先进行类型检查 .

3- 受保护字段

在Scala中, 受保护字段 (Protected Fields) 是指只能在当前类、子类或伴生对象中访问的字段 ;

通过使用 protected 关键字来声明字段, 可以实现字段的受保护访问权限 ;

示例:

  // 定义父类
  class Animal {
    protected var name: String = "Animal"

    def getName(): String = {
      name
    }
  }

  // 定义子类, 继承自 Animal
  class Dog extends Animal {
    def setName(newName: String): Unit = {
      name = newName
    }
  }


  def main(args: Array[String]): Unit = {
    // 创建子类实例
    val dog = new Dog()
    println(dog.getName()) // 输出: Animal
    dog.setName("Buddy")
    println(dog.getName()) // 输出: Buddy
  }
  • 在上面的示例中, Animal 类中的 name 字段被声明为受保护字段, 只能在 Animal 类及其子类中访问 ;
  • 子类 Dog 继承了 Animal 类, 并可以访问和修改 name 字段 ;
  • 通过这种方式, 受保护字段可以提供一定程度的访问控制, 保护字段不被外部类直接访问 ;

4- 超类的构造

在Scala中, 子类在构造时需要调用超类(父类) 的构造器 ;

子类可以通过 extends 关键字继承超类, 并在子类的构造器中调用超类的构造器 ;

示例:

  // 定义父类(超类)
  class Person(val name: String, val age: Int) {
    def displayInfo() = {
      println(s"Name: $name, Age: $age")
    }
  }

  // 定义子类, 继承父类 Person
  class Employee(name: String, age: Int, val role: String) extends Person(name, age) {
    def displayRole() = {
      println(s"Role: $role")
    }
  }

  def main(args: Array[String]): Unit = {
    // 创建子类实例
    val employee = new Employee("John Doe", 30, "Software Engineer")
    // 调用父类方法
    employee.displayInfo() // Output: Name: John Doe, Age: 30
    // 调用子类方法
    employee.displayRole() // Output: Role: Software Engineer
  }
  • 在上面的示例中, Employee 类继承自 Person 类, 并在其构造器中调用了 Person 类的构造器 ;
  • 通过这种方式, 子类可以通过调用超类(父类) 构造器来初始化超类的字段 ;
  • 这种机制确保了在构造子类实例时, 超类的构造器也会被正确调用 .

5- 重写字段和方法

在Scala中, 子类可以重写父类的 def 方法、val 字段和 var 字段 ;

当子类重写父类的 def 方法时, 子类可以提供新的实现 ;

当子类重写父类的 val 字段和 var 字段时, 子类可以重新定义字段的值 ;

示例:

  // 定义父类
  class Person {
    def greet(): Unit = {
      println("Hello, I am a Person !")
    }

    val name: String = "Person"
    var age: Int = 26
  }

  // 定义子类, 继承父类, 重写父类的方法和字段
  class Student extends Person {
    override def greet(): Unit = {
      println("Hello, I am a Student !")
    }

    override val name: String = "Student"
    //override var age: Int = 18 //  variable age cannot override a mutable variable
    age = 18
  }

  def main(args: Array[String]): Unit = {
    // 创建子类实例
    val student = new Student()
    student.greet() // Output: Hello, I am a Student !
    println(student.name) // Output: Student
    println(student.age) // Output: 18
  }
  • 在上面的示例中, Employee 类继承自 Person类, 并重写了 greet() 方法 和 name 字段 ;
  • 通过 override 关键字, 子类 Employee 提供了新的 greet() 实现, 以及重新定义了 age 和 name 字段的值 ;
  • 当创建 Employee 类的实例时, 调用 greet() 方法 将输出子类中重写的内容, 并访问 age 和 name 字段将返回子类中重写的值 ;
  • 注意: 在Scala中, 重写一个可变(mutable) 的变量 (var) 是不允许的 , 子类无法直接重写父类的 var 字段 ;
  • 子类继承父类的 var 字段, 并可以在子类中直接使用它 ;

6- 匿名子类

在Scala中, 可以使用匿名子类 (Anonymous Subclass) 来创建没有显示命名的子类 ;

匿名子类通常用于临时性的扩展或重写父类的行为, 而无需为其定义一个具名的类 ;

示例:

  // 定义父类
  class Person(val name: String) {
    def greet(): Unit = {
      println(s"Hello, My name is $name")
    }
  }

  // 创建匿名子类并重写父类方法
  val anonymousPerson = new Person("Anonymous") {
    override def greet(): Unit = {
      println(s"Hello,I am $name")
    }
  }

  def main(args: Array[String]): Unit = {
    
    // 调用匿名子类方法
    anonymousPerson.greet() // Output: Hello,I am Anonymous
  }
  • 上面的示例中, 我们定义了一个 Person 类, 然后使用匿名子类重写了 greet() 方法 ;
  • 通过创建一个没有显示类名的子类实例, 我们可以在其中提供新的实现 ;
  • 这种方式适用于需要临时性的定制化行为或重写父类方法的情况 ;

匿名子类在Scala中是一种灵活且常用的技术, 可以帮助简化代码结构并实现临时性的定制化需求 .

7- 抽象类

在Scala中, 抽象类 (Abstract Classes) 是一种类似于 Java中抽象类的概念 ;

抽象类可以包含抽象方法 (没有具体实现的方法) 和非抽象方法 (有具体实现的方法) ;

与 Traits 相比, 抽象类可以包含构造函数参数, 而 Traits 不支持构造函数参数 ;

通常情况下, 当需要创建一个基类, 该基类需要构造函数参数或者需要被 Java 代码调用时, 可以使用抽象类 ;

示例:

  // 定义一个抽象类
  abstract class Animal(name: String) {
    // 抽象方法, 子类必须实现
    def makeSound(): Unit

    // 非抽象方法, 具体实现
    def eat(food: String): Unit = {
      println(s"$name is eating $food")
    }
  }

  // 定义一个子类, 继承抽象类
  class Dog(name: String) extends Animal(name) {
    // 实现抽象方法
    override def makeSound(): Unit = {
      println("Woof Woof!")
    }
  }

  def main(args: Array[String]): Unit = {
    // 创建一个Dog对象
    val dog = new Dog("Buddy")
    // 调用子类的方法
    dog.makeSound() // Output: Woof Woof!
    dog.eat("bones") // Output: Buddy is eating bones
  }
  • 在上面的示例中, Animal 类是一个抽象类, 包含一个抽象方法 makeSound() 和一个非抽象方法 eat() ;
  • 子类 Dog 继承自 Animal 类, 并实现了抽象方法 makeSound() ;
  • 通过创建 Dog 类的示例, 我们可以调用抽象类中定义的方法 ;

抽象类在Scala中是一种重要的概念, 用于实现类似于 Java中的抽象类的功能 .

8- 抽象字段

在Scala中, 可以定义抽象字段 (Abstract Fields) 来要求字了提供具体的字段实现 ;

抽象字段可以是 val (不可变) 或 var (可变) ;

在抽象类中声明的抽象字段自行在子类中被具体化 ;

示例:

  // 定义一个抽象类
  abstract class Animal(name: String) {
    // 抽象的不可变字段
    val greeting: String

    // 抽象的可变字段
    var age: Int

    // 具体方法
    def sayHello(): Unit = {
      println(s"$greeting, my name is $name")
    }

    // 抽象方法
    def displayDetails(): Unit
  }

  // 定义一个子类, 继承抽象类
  class Dog(name: String) extends Animal(name) {
    // 实现抽象字段
    val greeting: String = "Hello"
    var age: Int = 3

    // 实现抽象方法
    override def displayDetails(): Unit = {
      println(s"My name is $name, I am $age years old.")
    }
  }

  def main(args: Array[String]): Unit = {
    // 创建一个Dog对象
    val dog = new Dog("Buddy")
    // 调用子类的方法
    dog.sayHello() // 输出: Hello, my name is Buddy
    dog.displayDetails() // 输出: My name is Buddy, I am 3 years old.
  }
  • 在上面的示例中, Animal 类是一个抽象类, 包含一个抽象的不可变字段 greeting 和一个抽象的可变字段 age ;
  • 子类 Dog 继承 Animal 类, 并提供了具体的字段实现 ;
  • 通过创建 Dog 类的实例, 我们可以调用抽象类中定义的方法, 并访问具体的字段值 ;

抽象字段在 Scala中运行你定义需要再子类中提供具体实例的字段 ;

这种机制有助于实现灵活的类设计和继承结构 .

9- Scala继承层级

在Scala中, 继承层级的根是 Any , 它是所有其他类的超类 ;

在Scala中, Any 有两个直接子类: AnyVal 和 AnyRef ;

AnyVal 是所有内建值类型的超类, 例如 Int 、Double 、Boolean 等 ;

而 AnyRef 则是所有引用类型(类) 的超类, 类似于 Java 中的 Object ;

在Scala中, 几乎所有的类都是 AnyRef 的子类, 因为他们都是引用类型 ;

AnyRef 继承在 Any , 而 Any 又是所有类的超类 ;

这种继承层级关系确保了在Scala中所有类都是有一些通用的方法和属性, 例如 equals 、hashCode 等 ;

示例, 展示 Any 、AnyRef 和 AnyVal 之间的继承关系:

    // Any 是Scala中的顶级父类，所有类的父类都是 Any。
    val anyValue: Any = "Hello"
    val anyRefValue: AnyRef = "Hello"
    val anyValValue: AnyVal = 12

    // AnyRef 是Scala中的顶级父类，所有引用类型的父类都是 AnyRef。
    val stringValue: String = "Hello"
    val listValue: List[Int] = List(1, 2, 3)

    // AnyVal 是Scala中的顶级父类，所有值类型的父类都是 AnyVal。
    val intValue: Int = 12
    val doubleValue: Double = 12.0
  • 在上面的示例中, Any 是所有类的超类, AnyRef 是所有引用类型的超类, 而 AnyVal 是所有值类型的超类 ;
  • 通过这种继承层级, Scala提供了一种统一的方式来处理不同类型的值和引用 ;

继承层级中的 Any、AnyRef 和 AnyVal 是Scala中非常重要的概念, 有助于理解Scala中类之间的关系和类型系统 .

10- 对象相等性

在Scala中, 对象相等性有两种概念: 引用相等性 (Reference Equality) 和结构相等性 (Structural Equality) ;

  1. 引用相等性: 引用相等性是指两个对象是否指向内存中的同一位置 ; 在Scala中, 可以使用 eq 和 ne 方法来检查两个对象是否引用同一个内存地址 .

    例如:

        val a = "hello"
    val b = "hello"
    val c = new String("hello")
    println(a eq b) // 输出: true，因为字符串字面量通常会被优化为共享实例
    println(a eq c) // 输出: false，尽管内容相同，但 c 是新创建的对象

  2. 结构相等性: 结构相等性是指两个对象的内容是否相等 ;

    • 在Scala中, 可以使用 == 和 != 运算符来检查两个对象的内容是否相等 ;
    • 对于引用类型, == 默认调用 equals 方法进行比较 ;

    示例:

        val a = "hello"
    val b = "hello"
    val c = new String("hello")
    println(a == b) // 输出: true
    println(a == c) // 输出: true
    println(a.equals(b)) // 输出: true
    println(a.equals(c)) // 输出: true
  • 除了上述方法外, Scala还提供了 equals 方法和 hashCade 方法用于自定义对象的相等性比较;
  • 如果需要自定义对象的相等性逻辑, 可以重写 equals 方法和 hashCode 方法 ;

总的来说, 在Scala中, 对象的相等性可以通过引用相等性和结构相等性来进行比较, 开发人员可以根据具体需求选择合适的比较方式 .

end

Taerge0110
关注
  • 12
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Scala继承
echo_ale的博客
05-15 295
1.extends Scala中，让子类继承父类，与Java一样，也是使用extends关键字 继承就代表，子类可以从父类继承父类的field和method；然后子类可以在自己内部放入父类所没有，子类特有的field和method；使用继承可以有效复用代码 子类可以覆盖父类的field和method；但是如果父类用final修饰，field和method用final修饰，则该类是无法被继承的，
Scala之继承
weixin_33985679的博客
07-21 73
1. 继承Scala语言通过 extends 关键字来继承类.那么继承一个类有什么好处呢? 子类除了拥有继承自超类的方法和字段(即为val(常量), var(变量)所定义的), 还可以添加自己需要的新方法和新字段, 而且不但可以重写(override)超类的方法, 还可以重写超类的字段.final 关键字在Scala中, 不仅可以将类声明为final, 而且可以将字段和方法声...
scala继承
lazy_moon的博客
08-14 1452
  继承 继承是面向对象编程语言的重要概念，简单一句话就是“儿子继承爸爸，拥有爸爸的很多可以被继承的特征（method和field）”。 scala中子类继承父类与java一样，使用“extends”关键字。 重写父类方法时使用“override”关键字。 使用父类的方法或变量时使用“super”关键字。 对象匹配和转换 classOf[T]看成Java里的T.class,可以精...
使用递归的方式去思考、编程
程序员学习圈
09-28 323
1.继承类 和Java一样使用extends关键字，在定义中给出子类需要而超类没有的字段和方法，或者重写超类的方法。 class Person { var name = "" } class Employee extends Person{ var salary = 0.0 def description = "员工姓名：" + name + " 薪水：...
scala-learn:scala学习笔记
03-14
本教程“scala-learn:scala学习笔记”旨在帮助初学者深入理解Scala的基础知识，同时也为有经验的程序员提供了一个复习和提升的平台。 1. **基础语法与数据类型** Scala的基础语法简洁而强大，包括变量声明（val和...
scala笔记：学习scala时的笔记
02-11
以下是一些在学习Scala时可能会遇到的关键知识点： 1. **基本语法与类型系统**： - Scala是强类型语言，变量声明时必须指定类型，但可以使用类型推断简化编写。 - `val`用于声明不可变变量，`var`用于声明可变...
scala学习笔记整理
05-09
在"scala学习笔记整理"中，我们可以深入探讨以下关键知识点： 1. **基础语法**：Scala的基础语法与Java有相似之处，但也有很多独特的特点。例如，它支持变量的不可变性（immutability），使用`val`声明常量，`var`...
scala学习笔记
04-13
以上内容覆盖了 Scala 编程语言的核心知识点，从基本语法到高级特性，为初学者提供了一个全面的学习指南。Scala 是一门功能强大且灵活的语言，适合于构建大型的、复杂的软件系统。希望这些知识点能够帮助读者更好地...
Scala-Tutorial:Scala语法学习笔记与程式码范例from 韩顺平老师教学
04-27
4. 继承：Scala支持单一继承，但可以通过trait实现多重行为继承。例如： ```scala class ChildClass extends ParentClass trait TraitExample { def traitMethod(): Unit } class InheritingClass extends ...
Scala 继承
张俊杰 的博客
11-16 302
概念 java的继承: 类单继承 scala的继承: 类也是单继承 scala没有接口, 但是提供了更加强大的 trail(特质) 接口 多实现 继承案例 继承是extends 复写父类的方法是override关键字 class A(val a: Int) { def this() { this(10) } println("A 主构造内的代码") def foo() = { println("A foo...") } } class B(val
Scala 继承
Simple 专栏
09-18 292
继承是面向对象的概念，用于代码的可重用性。可以通过使用extends关键字来实现继承。 为了实现继承，一个类必须扩展到其他类，被扩展类称为超类或父类。扩展的类称为派生类或子类。 示例 class SubClassName extends SuperClassName(){ /* Write your code * methods and fields etc. ...
scala的继承
汉子一枚
02-13 1127
继承 scala语言是支持面向对象编程的，我们也可以使用scala来实现继承，通过继承来减少重复代码。 定义语法 scala和Java一样，使用extends关键字来实现继承 可以在子类中定义父类中没有的字段和方法，或者重写父类的方法 类和单例对象都可以从某个父类继承 语法 scala class/object 子类 extends 父类 { … } 示例 | 类继承 定义一个Person类，再定...
Scala中的继承
hzp666的博客
04-23 224
1.Scala中的扩展类 使用 extends 继承父类 eg: abstract class People(){ val name:String def speak() def info(): Unit ={ printf("this people's name is %s", name) } } class Male(pname:String) extends People { val name = pname override def speak():.
【Scala 继承】Scala 中的继承
赖德发的博客
12-27 910
Scala继承一个基类跟Java很相似, 但我们需要注意以下几点： 1、重写一个非抽象方法必须使用override修饰符。 2、只有主构造函数才可以往基类的构造函数里写参数。 3、在子类中重写超类的抽象方法时，你不需要使用override关键字。 4、继承会继承父类的所有属性和方法，Scala 只允许继承一个父类。import java.io._class Point(val xc: Int
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值