Scala 访问修饰符（手把手讲解）

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

• 新项目:《从零手撸：仿小红书（微服务架构）》 正在持续爆肝中，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;演示链接： http://116.62.199.48:7070 ;
• 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 90w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 3100+ 小伙伴加入学习 ，欢迎点击围观

Scala 访问修饰符：控制代码可见性的门禁系统

在面向对象编程中，访问修饰符就像一座大厦的门禁系统，决定了代码的不同部分能够被哪些人（即程序中的其他类或对象）访问和操作。对于 Scala 开发者而言，理解 Scala 访问修饰符 的工作原理，不仅能提升代码的安全性，还能让程序结构更加清晰合理。本文将通过循序渐进的方式，结合实际案例，带您掌握这一核心概念。

一、访问修饰符的基础概念

在 Scala 中，访问修饰符用于定义类、对象、方法、字段等成员的可见性范围。这类似于现实生活中的权限管理：例如，银行金库的钥匙只能由特定人员持有，而公共休息区则向所有人开放。通过合理使用 private、protected 等修饰符，开发者可以避免代码被意外修改或滥用。

1.1 核心作用与分类

Scala 的访问修饰符分为四类：

• private：完全限制成员的可见性，仅允许当前定义的类或对象访问。
• protected：允许当前类及其子类访问成员。
• public（默认）：无限制，任何位置均可访问。
• 包级私有：通过省略修饰符实现，默认情况下同一包内的类可以互相访问。

1.2 作用域的层级关系

访问权限遵循“由内到外”的规则：

• private 的作用域最小，仅限当前定义的实体（如类或对象）。
• protected 的作用域扩展到子类，但无法被其他包中的类访问。
• public 则完全开放，但需注意过度开放可能引发的安全风险。

二、Scala 访问修饰符的语法与用法

2.1 private：最严格的门禁

private 修饰符如同一把加密钥匙，只有持有者（当前类或对象）才能使用。例如：

class BankAccount {
  private var balance: Double = 0.0  // 仅 BankAccount 类可直接访问

  def deposit(amount: Double): Unit = {
    balance += amount
  }

  def getBalance: Double = balance
}

在这个案例中，balance 字段被 private 保护，外部代码无法直接修改其值，只能通过 deposit 或 getBalance 方法间接操作。这种设计避免了数据被随意篡改的风险。

2.2 protected：家族内部的共享

protected 修饰符允许子类访问成员，但禁止外部类直接访问。这类似于家族内部共享的车库钥匙：

class Vehicle {
  protected def startEngine(): Unit = {
    println("Engine started")
  }
}

class Car extends Vehicle {
  def drive(): Unit = {
    startEngine()  // 子类可以访问 protected 方法
  }
}

// 外部类无法直接调用 startEngine()
// object External {
//   val v = new Vehicle()
//   v.startEngine() // 编译报错
// }

2.3 默认 public：开放但需谨慎

未明确修饰的成员默认为 public，可在任何位置访问。例如：

class PublicClass {
  def greet(): Unit = {
    println("Hello!")
  }
}

object Main extends App {
  val obj = new PublicClass()
  obj.greet()  // 可直接调用
}

但过度使用 public 可能导致代码难以维护。例如，如果某个字段被多个类依赖，后续修改时需全局排查所有调用点。

三、进阶用法：包级私有与限定作用域

3.1 包级私有：限制到整个包

通过在包内定义成员，可实现包级私有权限。例如：

// 文件位于 package mypackage
package mypackage

class PrivateInPackage {
  // 无修饰符，默认包级私有
  val secretKey: String = "abc123"
}

// 同一包内的类可访问 secretKey
class Helper extends PrivateInPackage {
  def printKey(): Unit = {
    println(secretKey)  // 允许访问
  }
}

但若在其他包中尝试访问，则会报错：

// 文件位于 package anotherpackage
package anotherpackage

import mypackage.PrivateInPackage

object Test {
  val obj = new PrivateInPackage()
  obj.secretKey  // 编译报错：secretKey 不可见
}

3.2 限定作用域：private[this] 和 protected[this]

当需要进一步缩小作用域时，可以使用 private[this] 或 protected[this]。例如：

class TicketChecker {
  private[this] var ticketCount = 0  // 仅当前实例可见

  def increment(): Unit = {
    ticketCount += 1
  }

  def getCount: Int = ticketCount
}

// 同一个对象实例可访问
val checker = new TicketChecker()
checker.increment()  // 允许

但若通过子类或外部引用尝试访问，则会失败：

class EnhancedChecker extends TicketChecker {
  override def increment(): Unit = {
    ticketCount += 2  // 编译报错：ticketCount 不可见
  }
}

四、继承场景下的访问控制

4.1 子类对父类成员的访问规则

当子类继承父类时，protected 成员的可见性受包限制：

• 如果父类和子类位于同一包中，protected 成员可被子类访问。
• 若位于不同包，则仅允许通过继承关系访问，但需显式声明 protected 的作用域。

例如：

// 父类在 package a
package a
class Parent {
  protected def internalMethod(): Unit = {
    // ...
  }
}

// 子类在 package b
package b
class Child extends Parent {
  internalMethod()  // 编译报错，因包不同
}

// 解决方案：在父类中指定包级保护
package a
class Parent {
  protected[a] def internalMethod(): Unit = {
    // ...
  }
}

4.2 防止意外覆盖：private[this] 的妙用

在设计库时，若希望方法仅由当前类实例调用，可用 private[this] 避免被子类覆盖：

abstract class Base {
  private[this] val id: String = java.util.UUID.randomUUID().toString

  def log(): Unit = {
    println(s"ID: $id")  // 允许访问
  }
}

class Derived extends Base {
  // 无法修改或访问 id 字段
}

五、常见误区与最佳实践

5.1 误区：private 总是绝对安全？

即使字段被 private 保护，仍可能通过反射等手段绕过限制。因此，关键数据应同时采用加密等安全措施。

5.2 最佳实践建议

• 谨慎使用 public：仅暴露必要接口，隐藏实现细节。
• 合理使用包结构：通过包划分模块，利用包级私有减少耦合。
• 测试访问权限：在单元测试中验证成员的可见性是否符合预期。

六、实战案例：构建安全的银行账户系统

package banking

class BankAccount {
  private var balance: Double = 0.0

  protected def setBalance(amount: Double): Unit = {
    if (amount >= 0) balance = amount
  }

  def deposit(amount: Double): Unit = {
    require(amount > 0, "Deposit amount must be positive")
    balance += amount
  }

  def withdraw(amount: Double): Unit = {
    require(amount > 0 && amount <= balance, "Invalid withdrawal amount")
    balance -= amount
  }

  // 包内可访问 getBalance，但外部需通过接口
  private[banking] def getBalance: Double = balance
}

// 包内辅助类可直接获取余额
class AuditHelper {
  def checkAccount(account: BankAccount): Unit = {
    println(s"Current balance: ${account.getBalance}")  // 允许访问
  }
}

// 外部包无法直接访问 getBalance
package object external {
  val account = new BankAccount()
  account.getBalance  // 编译报错
}

在这个案例中：

• balance 字段被 private 保护，防止直接修改。
• setBalance 方法为 protected，允许子类（如 AdminAccount）设置特殊值。
• getBalance 通过包级私有，确保只有同一模块内的类可直接获取余额。

结论

掌握 Scala 访问修饰符 是编写健壮、可维护代码的重要基础。通过合理设置权限，开发者既能保障数据安全，又能灵活控制代码模块间的交互。建议在实践中逐步尝试不同修饰符的组合，例如在接口类中使用 public 暴露必要方法，而在实现类中用 private 隐藏复杂逻辑。随着对这些规则的深入理解，您将能编写出更优雅、更可靠的 Scala 程序。