Scala 访问修饰符

I modificatori di accesso in Scala sono essentially gli stessi di Java, ovvero: private, protected, public.

Se non viene specificato un modificatore di accesso, di default, il livello di accesso degli oggetti Scala è pubblico.

Il modificatore private in Scala è più rigoroso rispetto a Java, in casi di classi annidate, la classe esterna non può accedere ai membri privati della classe annidata.

membri privati (Private)

usando la parola chiave private, i membri con questo segno sono visibili solo all'interno della classe o dell'oggetto che contiene la definizione del membro, la stessa regola si applica anche alle classi interne.

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

l'accesso non è legittimo per (new Inner).f() perché f dichiarato come private in Inner e l'accesso non è all'interno della classe Inner.

ma nell'InnerMost f nessun problema, perché questo accesso è incluso all'interno della classe Inner.

Java permette entrambi gli accessi perché permette agli oggetti di classe esterna di accedere ai membri privati delle classi interne.

membro protetto (Protected)

In Scala, l'accesso ai membri protetti è più rigoroso rispetto a Java. Questo perché permette l'accesso ai membri protetti solo nelle sottoclassi della classe che ha definito il membro. In Java, i membri marcati con la parola chiave protected possono essere acceduti non solo dalle sottoclassi della classe che ha definito il membro, ma anche dalle altre classi nello stesso pacchetto.

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

Nel caso precedente, l'accesso di Sub a f non presenta problemi perché f è dichiarato come protected in Super, e Sub è una sottoclasse di Super. Al contrario, l'accesso di Other a f non è permesso perché Other non eredita da Super. Tuttavia, questo è anche accettato in Java perché Other e Sub si trovano nello stesso pacchetto.

membro pubblico (Public)

In Scala, se non viene specificato alcun modificatore, il valore predefinito è public. Questo membro può essere acceduto da qualsiasi parte.

class Outer {
　　　class Inner {
　　　　　　def f() { println("f") }
　　　　　　class InnerMost {
　　　　　　　　　f() // corretto
　　　　　　}
　　　}
　　　(new Inner).f() // corretto perché f() è pubblico
}

protezione di ambito

In Scala, i modificatori di accesso possono essere enfatizzati utilizzando aggettivi. La forma è:

private[x]　
o　
protected[x]

Ecco x che rappresenta un pacchetto, una classe o un oggetto singleton di appartenenza. Se scritto come private[x], si legge: "Questo membro è privato per tutti i tipi diversi dalla classe o dal pacchetto specificato [...] e dai loro oggetti companion, per tutti gli altri tipi.

这种技巧在跨越了若干包的大型项目中非常有用，它允许你定义一些在你项目的若干子包中可见但对于项目外部的客户却始终不可见的东西。

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
　　　　　　　　}
　　　　}
}

在上面的示例中，类 Navigator 被标记为 private[bobsrockets]，这意味着这个类对于包含在 bobsrockets 包中的所有类和对象都是可见的。

比如说，从 Vehicle 对象中对 Navigator 的访问是被允许的，因为对象 Vehicle 包含在包 launch 中，而 launch 包在 bobsrockets 中，相反，所有在包 bobsrockets 之外的代码都不能访问类 Navigator。