四、Scala深入面向对象：类、对象与伴生关系

在前几节中，我们学习了 Scala 的基础语法和流程控制。现在，我们将深入探索 Scala 作为一门纯粹的面向对象语言的核心。在 Scala 中，万物皆对象，没有像 Java 那样的原始类型和静态成员的区分。本节将重点介绍如何定义对象的蓝图，以及如何使用 Scala 独特的单例对象和伴生机制。

思维导图

一、类和对象

类 是创建对象的模板或蓝图。它定义了一类事物共同的属性 (成员变量) 和行为 (成员方法)。
对象，也称为实例，是根据类这个蓝图创建出来的具体实体。

基本语法：

class ClassName {// 成员变量 (字段)// 成员方法
}// 使用 new 关键字创建类的实例 (对象)
val objectName = new ClassName()

二、成员变量与成员方法

1. 定义和访问成员变量

在类中定义的变量或常量，称为成员变量或字段。

class Person {// 定义一个可变的成员变量 namevar name: String = "Unknown"// 定义一个不可变的成员变量 (常量) ageval age: Int = 0
}// 创建 Person 类的对象
val person1 = new Person()// 访问和修改成员变量
println(person1.name) // 输出: Unknown
person1.name = "Alice"
println(person1.name) // 输出: Alice
// person1.age = 25 // 这行会编译错误，因为 age 是 val (常量)

2. 使用下划线 _ 初始化成员变量

在 Scala 中，var 类型的成员变量必须被初始化。如果你暂时不想给它一个有意义的初始值，可以使用下划线 _ 作为占位符，Scala 会为其赋予该类型的默认零值。

类型	默认零值
数值类型 (Int, Double, etc.)	0
Boolean	false
Char	\u0000
所有引用类型 (AnyRef)	null

代码案例：

class Student {var name: String = _ // 初始化为 nullvar age: Int = _     // 初始化为 0var isMale: Boolean = _ // 初始化为 false
}val student1 = new Student()
println(s"Name: ${student1.name}, Age: ${student1.age}, Is Male: ${student1.isMale}")
// 输出: Name: null, Age: 0, Is Male: false

注意： 这种下划线初始化的方式在现代 Scala 编程中使用得越来越少，因为它容易引入 NullPointerException。更推荐的做法是提供一个有意义的初始值，或者使用Option 类型来表示可能缺失的值。

3. 定义和访问成员方法

成员方法定义了对象的行为。

class Circle {val radius: Double = 5.0// 定义一个计算面积的方法def getArea(): Double = {Math.PI * radius * radius}
}val c1 = new Circle()
// 调用方法
val area = c1.getArea()
println(s"The area of the circle is: $area")

三、访问权限修饰符

Scala 通过访问权限修饰符来控制成员的可见性，以实现封装。

修饰符	描述
(无修饰符)	默认为 public，在任何地方都可以访问。
private	私有成员，只能在定义该成员的类或其伴生对象内部访问。
protected	受保护成员，只能在定义该成员的类及其子类中访问。
private[this]	对象私有，比 private 更严格。只能在当前对象实例中访问，即使是同一个类的其他对象也不能访问。
private[包名]	包私有，成员的可见性被限定在指定的包及其子包中。

代码案例：

class Animal {private var privateName = "Secret"protected var protectedAge = 2def printInfo(): Unit = {println(s"This is a private name: $privateName") // 类内部可以访问 private}
}class Dog extends Animal {def getAge(): Int = {// println(privateName) // 错误：子类不能访问父类的 private 成员protectedAge // 正确：子类可以访问父类的 protected 成员}
}val animal = new Animal()
// println(animal.privateName) // 错误：外部不能访问 private 成员
// println(animal.protectedAge) // 错误：外部不能访问 protected 成员
animal.printInfo()val dog = new Dog()
println(s"Dog's age: ${dog.getAge()}")

四、类的构造器

构造器是在创建对象时自动调用的特殊方法，用于初始化对象。

1. 主构造器

主构造器直接定义在类名之后的参数列表中。
主构造器会执行类定义中所有的语句。
如果主构造器的参数没有用 val 或 var 声明，它将是一个私有的不可变字段，仅在类内部可见。
如果用 val 或 var 声明，该参数会成为一个公共的成员变量。

代码案例：

// name 和 age 是主构造器的参数，并成为公共的不可变/可变成员变量
class Employee(val name: String, var age: Int) {// 这部分代码是主构造器的一部分，在 new Employee(...) 时执行println(s"New employee created: $name, age $age")// 一个普通的成员方法def work(): Unit = println(s"$name is working.")
}val emp1 = new Employee("Alice", 30)
println(emp1.name) // 可以访问
emp1.age = 31 // 可以修改

2. 辅助构造器

一个类可以有多个辅助构造器。
辅助构造器的名称必须是 this。
关键规则：每个辅助构造器的第一行必须直接或间接地调用主构造器 (或另一个已定义的辅助构造器)。

代码案例：

class Car(val brand: String, val year: Int) {var color: String = "White"// 辅助构造器一：提供品牌、年份和颜色def this(brand: String, year: Int, color: String) {this(brand, year) // 必须先调用主构造器this.color = color}// 辅助构造器二：只提供品牌def this(brand: String) {this(brand, 2024) // 调用主构造器，年份默认为 2024}
}val car1 = new Car("Toyota", 2023)
val car2 = new Car("BMW", 2024, "Black")
val car3 = new Car("Ford")
println(s"${car3.brand} color is ${car3.color} and year is ${car3.year}")

五、单例对象、main方法与伴生对象

1. 单例对象

在 Scala 中，使用 object 关键字定义的不是类，而是一个单例对象——它是一个全局唯一的实例。
单例对象不能被 new，它的所有成员都类似于 Java 中的静态成员。

代码案例：

object Logger {var level: String = "INFO"def log(message: String): Unit = {println(s"[$level] $message")}
}// 直接通过对象名访问成员
Logger.level = "DEBUG"
Logger.log("This is a debug message.")

2. main 方法

Scala 应用程序的入口点是一个名为 main 的方法，它必须定义在一个单例对象中。

两种实现方式：

1. 标准 main 方法：

object MyApp {def main(args: Array[String]): Unit = {println("Hello from the main method!")}
}

2. 继承 App 特质 (更简洁)：

object MyApp extends App {// 这里的代码会直接作为 main 方法体执行println("Hello from the App trait!")// 命令行参数可以通过 args 变量访问if (args.length > 0) {println(s"First argument: ${args(0)}")}
}

3. 伴生对象

当一个单例对象与一个类具有相同的名称，并且它们定义在同一个源文件中时，这个对象被称为该类的伴生对象，该类被称为该对象的伴生类。

核心特性：
伴生类和伴生对象可以互相访问对方的私有 (private) 成员。
常见用途：

在伴生对象中放置类似于 Java 静态方法的工具方法。
在伴生对象中定义工厂方法 (特别是名为 apply 的方法)，用于创建伴生类的实例，隐藏 new 关键字。

代码案例：

// 伴生类
class User private (val id: Int, val name: String) { // 主构造器设为 privateprivate def secretMethod(): String = s"User $name has a secret."def greet(): Unit = {// 访问伴生对象的私有成员println(User.defaultGreeting + ", " + name)}
}// 伴生对象
object User {private val defaultGreeting = "Welcome"// 工厂方法，可以访问 User 类的私有构造器def apply(name: String): User = {val newId = scala.util.Random.nextInt(1000)new User(newId, name)}def printSecret(user: User): Unit = {// 访问 User 实例的私有方法println(user.secretMethod())}
}// 使用伴生对象的 apply 工厂方法创建实例 (无需 new)
val user1 = User("Bob")
user1.greet()
User.printSecret(user1)// val user2 = new User(10, "Charlie") // 错误：构造器是私有的

六、综合案例

在 Scala 中，工具类 (包含纯粹的功能方法，不维护状态) 通常被实现为单例对象。

代码案例：一个简单的字符串工具对象

object StringUtils {/*** 判断字符串是否为空 (null 或 "")* @param s 待检查的字符串* @return 如果为空则返回 true，否则返回 false*/def isEmpty(s: String): Boolean = {s == null || s.trim.isEmpty}/*** 将字符串首字母大写* @param s 待转换的字符串* @return 转换后的字符串*/def capitalize(s: String): String = {if (isEmpty(s)) s else s.substring(0, 1).toUpperCase + s.substring(1)}
}// 在另一个对象中（例如主程序）使用工具类
object MainApp extends App {val str1 = "hello scala"val str2 = "  "val str3: String = nullprintln(s"'${str1}' is empty? ${StringUtils.isEmpty(str1)}")println(s"'${str2}' is empty? ${StringUtils.isEmpty(str2)}")println(s"Capitalized '${str1}': ${StringUtils.capitalize(str1)}")
}

---

练习题

题目一：简单类定义
定义一个 Book 类，包含两个不可变的成员变量：title (String) 和 author (String)。

题目二：创建和访问对象
创建 Book 类的一个实例，title 为 “Programming in Scala”，author 为 “Martin Odersky”。然后打印出这本书的标题。

题目三：成员方法
为 Book 类添加一个名为 getInfo 的方法，该方法返回一个格式为 "Title by Author" 的字符串。

题目四：下划线初始化
定义一个 Movie 类，包含一个可变的成员变量 director (String)，使用下划线 _ 进行默认初始化。创建实例后打印出 director 的初始值。

题目五：主构造器
定义一个 Laptop 类，其主构造器接收 brand (String, 不可变) 和 ramInGB (Int, 可变) 两个参数，并将它们直接定义为公共成员变量。

题目六：辅助构造器
为 Laptop 类添加一个辅助构造器，该构造器只接收 brand 参数，并默认将 ramInGB 设置为 8。

题目七：访问修饰符
定义一个 BankAccount 类，其中 balance (Double) 是私有的。提供一个公共的 deposit(amount: Double) 方法和一个公共的 getBalance() 方法来访问余额。

题目八：单例对象
创建一个名为 MathConstants 的单例对象，在其中定义两个常量：PI (值为 3.14159) 和 E (值为 2.71828)。

题目九：main 方法
创建一个名为 EntryPoint 的单例对象，并继承 App 特质，在其中打印 “Scala application started!”。

题目十：伴生对象与私有成员
定义一个 Circle 类，其主构造器接收一个私有的 radius (Double) 参数。然后，为其创建一个伴生对象，该对象有一个 calculateArea(c: Circle) 方法，可以计算并返回给定 Circle 实例的面积 (面积 = PI * r * r)。

题目十一：apply 工厂方法
在 Circle 的伴生对象中添加一个 apply 方法，该方法接收一个 radius 参数，并返回一个新的 Circle 实例。这样就可以使用 Circle(5.0) 来创建对象。

题目十二：工具类方法
在之前的 StringUtils 单例对象中，添加一个名为 reverse 的方法，接收一个字符串并返回其反转后的结果。

题目十三：主构造器代码块
修改 Employee 类的定义，在其主构造器代码块中添加一条逻辑：检查传入的 age 是否小于18，如果是，则打印一条警告信息 “Warning: Employee age is below 18.”。

题目十四：对象私有成员 private[this]
定义一个 Point 类，包含 x 和 y 两个坐标。再定义一个 isSameAs(other: Point) 方法，比较当前点是否与另一个点相同。然后，修改 x 和 y 为 private[this]，并观察 isSameAs 方法是否还能正常编译。如果不能，解释原因。

题目十五：综合案例
创建一个 Counter 类，它有一个私有的、可变的 count 变量，初始值为0。类中提供 increment() 方法 (每次将count加1) 和 current() 方法 (返回当前count值)。为其创建一个伴生对象，提供一个 apply 方法，允许通过 Counter() 创建新实例。

答案与解析

答案一：

class Book(val title: String, val author: String)

解析： 在主构造器参数前使用 val 是将参数直接定义为公共不可变成员变量的简洁语法。

答案二：

val myBook = new Book("Programming in Scala", "Martin Odersky")
println(myBook.title)

解析： 使用 new 关键字和类名来创建对象，通过 . 操作符访问其成员。

答案三：

class Book(val title: String, val author: String) {def getInfo(): String = {s"$title by $author"}
}
val myBook = new Book("A Brief History of Time", "Stephen Hawking")
println(myBook.getInfo())

解析： def 用于在类中定义方法。s"" 字符串插值器用于方便地格式化字符串。

答案四：

class Movie {var director: String = _
}
val m = new Movie()
println(m.director) // 输出: null

解析： String 是引用类型 (AnyRef)，其默认零值是 null。

答案五：

class Laptop(val brand: String, var ramInGB: Int)

解析： val 使 brand 成为不可变成员，var 使 ramInGB 成为可变成员。

答案六：

class Laptop(val brand: String, var ramInGB: Int) {// 辅助构造器def this(brand: String) {this(brand, 8) // 调用主构造器}
}
val defaultLaptop = new Laptop("Dell")
println(s"${defaultLaptop.brand} has ${defaultLaptop.ramInGB}GB RAM")

解析： 辅助构造器 def this(...) 必须在其第一行调用另一个构造器。

答案七：

class BankAccount {private var balance: Double = 0.0def deposit(amount: Double): Unit = {if (amount > 0) balance += amount}def getBalance(): Double = {balance}
}

解析： private 关键字将 balance 的访问权限限制在类内部，外部只能通过公共的 deposit 和 getBalance 方法进行交互，实现了封装。

答案八：

object MathConstants {val PI = 3.14159val E = 2.71828
}
println(MathConstants.PI)

解析： object 关键字创建了一个全局唯一的单例对象。

答案九：

object EntryPoint extends App {println("Scala application started!")
}

解析： 继承 App 特质是创建可执行应用程序的最简洁方式，对象体内的代码会自动成为 main 方法的内容。

答案十：

class Circle private (val radius: Double)object Circle {def calculateArea(c: Circle): Double = {// 可以访问 Circle 的私有成员 radiusMath.PI * c.radius * c.radius}
}

解析： 伴生对象 Circle 可以访问伴生类 Circle 的 private 成员 radius。

答案十一：

class Circle private (val radius: Double)object Circle {def apply(radius: Double): Circle = {new Circle(radius)}// ... calculateArea 方法 ...
}val myCircle = Circle(5.0) // 无需 new，直接调用 apply 方法

解析： apply 方法是一个特殊的语法糖，允许你像调用函数一样创建对象。

答案十二：

object StringUtils {// ... isEmpty, capitalize 方法 ...def reverse(s: String): String = {if (s == null) s else s.reverse}
}
println(StringUtils.reverse("scala"))
```*   **解析：** `String` 类型自带 `.reverse` 方法，可以直接使用。**答案十三：**
```scala
class Employee(val name: String, var age: Int) {if (age < 18) {println(s"Warning: Employee $name's age is below 18.")}def work(): Unit = println(s"$name is working.")
}
val youngEmployee = new Employee("Tom", 17)

解析： 类定义体中、成员方法之外的代码都属于主构造器的一部分，会在对象创建时执行。

答案十四：

class Point(private[this] val x: Int, private[this] val y: Int) {def isSameAs(other: Point): Boolean = {// this.x == other.x // 这行代码会编译错误false // 仅为使代码完整}
}

解析： 代码无法正常编译。因为 private[this] 是对象私有的，意味着只有当前对象 (this) 才能访问 x 和 y。在 isSameAs 方法中，other.x 尝试访问另一个Point 对象的 x 字段，这是不被允许的。如果使用 private，则可以访问，因为 private 允许同一类的不同实例之间互相访问私有成员。

答案十五：

class Counter private {private var count: Int = 0def increment(): Unit = {count += 1}def current(): Int = {count}
}object Counter {def apply(): Counter = new Counter()
}val c1 = Counter()
c1.increment()
c1.increment()
println(c1.current()) // 输出: 2

解析： 这个例子结合了私有构造器、私有成员、公共方法和伴生对象的 apply 工厂方法，是一个典型的Scala封装模式。将构造器设为私有，强制用户通过伴生对象的工厂方法来创建实例。

日期：2025年9月14日
专栏：Scala教程