Scala类继承与单例对象

本文详细介绍了Scala中的类继承特性,包括重写方法需使用override关键字及主构造函数的重要性。同时,讨论了Scala如何通过伴生对象实现单例模式,提供了一种不同于静态成员的单例实现方式。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

一、Scala类继承

Scala继承一个基类跟Java很相似,只多了两点限制:1、重写方法需要override关键字,2、只有主构造函数才可以往基类的构造函数里写参数。

Scala的副构造函数必须调用主构造函数或另一个构造函数,在Scala里主构造函数如同一道关卡,类的实例需要通过他来初始化。

示例:

class Vehicle (val id:Int, val year:Int){

  override def toString() : String = "ID: " + id + " Year: " + year
  
  def make(name: String) = {
    println("Vehicle make name "+ name)
  }
}

class Car(override val id: Int, override val year: Int,
    var fuelLevel: Int)extends Vehicle(id, year) {

  override def toString() : String = super.toString() + " Fuel Level: " + fuelLevel
  
  
  override def make(name: String) = {
    println("Car make name "+ name)
  }
}

调用:

val car : Vehicle = new Car(1, 2009, 10)
println(car)
println(car.make("bmw"))

输出:

ID: 1 Year: 2009 Fuel Level: 10
Car make name bmw


二、Scala单例对象

Scala是没有静态对象和属性的,但他拥有伴生对象,

我们利用伴生对象来实现Scala的单例,如:

// 私有构造方法
class Marker private(val color:String) {

  println("Creating " + this)
  
  override def toString(): String = "marker color "+ color
  
}

// 伴生对象,与类共享名字,可以访问类的私有属性和方法
object Marker{
  
    private val markers: Map[String, Marker] = Map(
      "red" -> new Marker("red"),
      "blue" -> new Marker("blue"),
      "green" -> new Marker("green")
    )
    
    def apply(color:String) = {
      if(markers.contains(color)) markers(color) else null
    }
  
    
    def getMarker(color:String) = { 
      if(markers.contains(color)) markers(color) else null
    }
}

使用:

// 方法糖 apply
println(Marker("red"))

// 单例函数调用,省略了.(点)符号
println(Marker getMarker "blue")

输出:

Creating marker color red
Creating marker color blue
Creating marker color green
marker color red
marker color blue






### Scala 对象的概念及用法 #### 1. Scala 中的 (Class) Scala 是一种完全支持面向对象编程的语言,因此它提供了 `class` 关键字用于定义。通过可以封装数据和行为,并作为创建对象的基础模板。 在 Scala 中,可以通过以下方式定义: ```scala class Person(name: String, age: Int) { def introduce(): Unit = { println(s"My name is $name and I am $age years old.") } } ``` 上述代码展示了如何定义一个简 `Person`,其中包含了两个字段 `name` 和 `age`,以及一个方法 `introduce()`[^3]。 要创建的对象,可以使用 `new` 关键字: ```scala val person = new Person("Alice", 25) person.introduce() // 输出: My name is Alice and I am 25 years old. ``` #### 2. Scala 中的对象 (Object) Scala 提供了单例对象的概念,这是通过 `object` 关键字实现的。单例对象在整个应用程序生命周期中只有一个实存在,似于 Java 中的静态成员集合体。 以下是单例对象的一个简子: ```scala object MathUtils { def add(a: Int, b: Int): Int = a + b } println(MathUtils.add(3, 5)) // 输出: 8 ``` 在这个子中,`MathUtils` 是一个单例对象,可以直接调用其方法而无需显式实化[^4]。 #### 3. 伴生对象 (Companion Object) 当单例对象的名字其对应的名字相同时,这种单例对象被称为 **伴生对象**。伴生对象通常用来存储级别的属性或方法(相当于 Java 中的静态成员)。 下面是一个伴生对象的子: ```scala class Counter(var count: Int) object Counter { def apply(initialCount: Int): Counter = new Counter(initialCount) } val counter = Counter(0) // 使用伴生对象的 apply 方法创建实 counter.count += 1 // 修改计数器的值 println(counter.count) // 输出: 1 ``` 在这里,`Counter` 有一个伴生对象,该伴生对象提供了一个便捷的方法 `apply` 来简化实化的操作[^5]。 #### 4. 构造器 (Constructor) Scala 支持两种型的构造器:主构造器和辅助构造器。 - 主构造器是在头部分直接定义的参数列表的一部分。 - 辅助构造器则允许额外的方式初始化对象。 示如下: ```scala class Animal(val name: String) { // 主构造器 def this() = this("Unknown") // 辅助构造器 } val dog = new Animal("Dog") val unknownAnimal = new Animal() println(dog.name) // 输出: Dog println(unknownAnimal.name)// 输出: Unknown ``` #### 5. 抽象 (Abstract Class) 抽象是一种无法被实化的,主要用于定义子需要遵循的标准接口或者共享的行为模式。 示代码如下: ```scala abstract class Shape { def area: Double } class Circle(radius: Double) extends Shape { override def area: Double = math.Pi * radius * radius } val circle = new Circle(5) println(circle.area) // 输出: 78.53981633974483 ``` 在此处,`Shape` 定义了一个抽象方法 `area`,任何继承自它的具体都必须实现这一方法。 --- ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值