Scala 访问修饰符

Scala access modifiers are basically the same as Java, including: private, protected, public.

If no access modifier is specified, by default, the access level of Scala objects is public.

The private qualifier in Scala is more strict than in Java, even the outer class cannot access the private members of the nested class in the case of nested classes.

Private (Private) Members

Members marked with the private keyword are only visible within the class or object that contains the member definition, and the same rule applies to inner classes.

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

Der Zugriff (new Inner).f() ist ungültig, weil f wird in Inner als private deklariert, und der Zugriff liegt nicht innerhalb der Klasse Inner.

aber im InnerMost zugreifen f kein Problem, da dieser Zugriff im Innern der Klasse Inner enthalten ist.

Java erlaubt beide Zugriffe, da es dem externen Klassenzugriff auf die privaten Members der inneren Klasse erlaubt.

Geschützte (Protected) Members

In Scala ist der Zugriff auf geschützte (Protected) Members etwas strenger als in Java. Dies liegt daran, dass nur geschützte Members in den Unterklassen der Klasse, in der der Member definiert ist, zugänglich sind. In Java können Members, die mit dem Schlüsselwort protected gekennzeichnet sind, von Unterklassen der Klasse und anderen Klassen im selben Paket zugänglich sein.

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

Im obigen Beispiel hat die Sub-Klasse keine Probleme mit dem Zugriff auf f, da f in Super als protected deklariert ist und Sub eine Unterklasse von Super ist. Im Gegensatz dazu ist der Zugriff von Other auf f nicht erlaubt, da Other nicht von Super abgeleitet ist. Dies wird im Java ebenfalls akzeptiert, da Other und Sub im selben Paket sind.

Öffentliche (Public) Members

In Scala ist, wenn keine Modifikatoren angegeben werden, der Standardwert public. Solche Members sind überall zugänglich.

class Outer {
　　　class Inner {
　　　　　　def f() { println("f") }
　　　　　　class InnerMost {
　　　　　　　　　f()　//　Richtig
　　　　　　}
　　　}
　　　(new Inner).f()　//　Richtig, da f() öffentlich ist
}

Bereichsschutz

In Scala können Zugriffsmodifikatoren durch die Verwendung von Determinanten betont werden. Die Formatierung ist:

private[x]　
oder　
protected[x]

Hierbei verweist x auf ein bestimmtes Paket, eine Klasse oder ein Singleton-Objekt. Wenn es so geschrieben wird private[x], wird es gelesen als "Dieser Member ist außerhalb von [...] der Klasse oder außerhalb von [...] des Pakets der Klasse und ihrer Begleitobjekte als private sichtbar, für alle anderen Klassen jedoch private.

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

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。