在Scala中，面向对象的权限控制主要通过访问修饰符来实现。Scala提供了以下几种访问修饰符来控制类、对象、成员变量和方法的访问权限：

1. 默认访问权限（无修饰符）

• 如果没有指定任何访问修饰符，成员默认是public的，即可以在任何地方访问。

2. private 修饰符

• private 修饰的成员只能在定义该成员的类或对象内部访问。

• 子类无法访问父类的 private 成员。

class MyClass {
  private val secret = 42
  def printSecret(): Unit = {
    println(secret)  // 可以访问
  }
}

val obj = new MyClass
// obj.secret  // 错误：无法访问 private 成员
obj.printSecret()  // 输出: 42

3. protected 修饰符

• protected 修饰的成员可以在定义该成员的类及其子类中访问。

• 与 Java 不同，Scala 的 protected 成员不能在同一包的其他类中访问。

class Parent {
  protected val value = 10
}

class Child extends Parent {
  def printValue(): Unit = {
    println(value)  // 可以访问
  }
}

val child = new Child
child.printValue()  // 输出: 10
// child.value  // 错误：无法访问 protected 成员

4. private[this] 修饰符

• private[this] 修饰的成员只能在当前实例中访问，即使是同一个类的其他实例也无法访问。

• 这种修饰符通常用于确保对象的封装性。

class MyClass {
  private[this] val secret = 42
  def compare(other: MyClass): Boolean = {
    // this.secret == other.secret  // 错误：无法访问 other.secret
    this.secret == 42  // 只能访问当前实例的 secret
  }
}

5. protected[this] 修饰符

• protected[this] 修饰的成员只能在当前实例及其子类的实例中访问。

• 与 private[this] 类似，但允许子类访问。

class Parent {
  protected[this] val value = 10
}

class Child extends Parent {
  def compare(other: Child): Boolean = {
    // this.value == other.value  // 错误：无法访问 other.value
    this.value == 10  // 只能访问当前实例的 value
  }
}

6. 包级访问权限

• Scala 允许通过 private[包名] 或 protected[包名] 来限制成员的访问范围。

• 这种修饰符允许成员在指定的包及其子包中访问。

package com.example {
  class MyClass {
    private[example] val value = 42  // 只能在 com.example 包及其子包中访问
  }
}

package com.example.sub {
  class SubClass {
    def printValue(): Unit = {
      val obj = new com.example.MyClass
      println(obj.value)  // 可以访问
    }
  }
}

总结

• private：仅限类内部访问。

• protected：类及其子类访问。

• private[this]：仅限当前实例访问。

• protected[this]：当前实例及其子类实例访问。

• 包级访问：通过 private[包名] 或 protected[包名] 控制包内访问权限。

Scala 的权限控制机制比 Java 更加灵活，能够更好地支持封装和模块化设计。