Scala 访问修饰符

Los modificadores de acceso en Scala son básicamente iguales a los de Java, incluyendo: private, protected, public.

Si no se especifica un modificador de acceso, por defecto, el nivel de acceso de los objetos Scala es público.

El modificador private en Scala es más estricto que en Java, incluso la clase externa no puede acceder a los miembros privados de la clase anidada.

Miembros privados (Private)

Modificado con la palabra clave private, los miembros marcados con este identificador solo son visibles dentro de la clase o objeto que contiene la definición del miembro, y la misma regla se aplica a las clases internas.

class Outer{
　　　　class Inner{
　　　　private def f(){ println("f") }
　　　　class InnerMost{
　　　　　　　　f()　//　Correcto
　　　　　　　　}
　　　　}
　　　　(new Inner).f()　//Incorrecto
}

El acceso (new Inner).f() no es válido porque f declarado como private en Inner, y el acceso no está dentro de la clase Inner.

pero al acceder desde InnerMost f No hay problemas, porque este acceso está dentro de la clase Inner.

Java permite estos dos tipos de acceso porque permite que las clases externas accedan a miembros privados de las clases internas.

Miembros protegidos (Protected)

En Scala, el acceso a miembros protegidos es más estricto que en Java. Porque solo permite que los miembros protegidos sean accesibles en subclases de la clase que definió el miembro. En Java, los miembros marcados con protected pueden ser accedidos por subclases de la clase que definió el miembro, así como por otras clases en el mismo paquete.

package p{
class Super{
　　　　protected def f() { println("f") }
　　　　}
　　　　　　　　class Sub extends Super{
　　　　　　　　　　　　f()
　　　　　　　　}
　　　　　　　　class Other{
　　　　　　　　　　　　　　　　(new Super).f()　//Incorrecto
　　　　　　　　}
}

En el ejemplo anterior, no hay problemas de acceso de Sub a f, porque f se declara como protected en Super y Sub es una subclase de Super. Por el contrario, el acceso de Other a f no está permitido, porque Other no hereda de Super. Esto también es aceptado en Java, porque Other y Sub están en el mismo paquete.

Miembros públicos (Public)

En Scala, si no se especifica ningún modificador, se considera por defecto público. Este miembro puede ser accedido en cualquier lugar.

class Outer {
　　　class Inner {
　　　　　　def f() { println("f") }
　　　　　　class InnerMost {
　　　　　　　　　f()　//　Correcto
　　　　　　}
　　　}
　　　(new Inner).f()　//　Correcto porque f() es público
}

Protección de ámbito

En Scala, los modificadores de acceso se pueden enfatizar usando cualificadores. El formato es:

private[x]　
o　
protected[x]

Aquí, x representa un paquete, clase o objeto singleton. Si se escribe como private[x], se lee "Este miembro es privado para todos los tipos de clase o paquetes en [...] y sus objetos acompañantes, pero es privado para todos los otros tipos de clase.

Esta técnica es muy útil en proyectos grandes que cruzan varios paquetes, ya que permite definir algunas cosas que son visibles en varios subpaquetes de tu proyecto pero siempre invisibles para los clientes externos del proyecto.

package bobsrockets{
　　　　package navigation{
　　　　　　　　private[bobsrockets] class Navigator{
　　　　　　　　　protected[navigation] def useStarChart(){}
　　　　　　　　　class LegOfJourney{
　　　　　　　　　　　　　private[Navigator] val distance =　100
　　　　　　　　　　　　　}
　　　　　　　　　　　　private[this] var speed =　200
　　　　　　　　　　　　}
　　　　　　　　}
　　　　　　　　package launch{
　　　　　　　　import navigation._
　　　　　　　　object Vehicle{
　　　　　　　　private[launch] val guide = new Navigator
　　　　　　　　}
　　　　}
}

En el ejemplo anterior, la clase Navigator se marca como private[bobsrockets], lo que significa que esta clase es visible para todas las clases y objetos que se incluyen en el paquete bobsrockets.

Por ejemplo, el acceso a Navigator desde el objeto Vehicle está permitido, ya que el objeto Vehicle se incluye en el paquete launch, y el paquete launch se incluye en bobsrockets, por el contrario, todo el código que está fuera del paquete bobsrockets no puede acceder a la clase Navigator.