Scala-Zugriffsmodifikatoren
In Scala werden Zugriffsmodifikatoren verwendet, um die Sichtbarkeit und die Zugriffsberechtigungen von Klassen, Objekten, Traits und deren Mitgliedern (wie Feldern und Methoden) zu steuern.
Scala-Zugriffsmodifikatoren sind im Wesentlichen dieselben wie in Java: private, protected und public.
Wenn kein Zugriffsmodifikator angegeben wird, ist die Zugriffsebene von Scala standardmäßig public.
Der private-Qualifizierer in Scala ist strenger als in Java. Bei verschachtelten Klassen kann die äußere Klasse nicht einmal auf die privaten Mitglieder der verschachtelten Klasse zugreifen.
Private Mitglieder
Mit dem Schlüsselwort private gekennzeichnete Mitglieder sind nur innerhalb der Klasse oder des Objekts sichtbar, das die Definition des Mitglieds enthält. Dieselbe Regel gilt auch für innere Klassen.
Beispiel
class Inner{
private def f(){
println("f")
}
class InnerMost{
f() // Korrekt
}
}
(new Inner).f() // Error
}
(new Inner).f( )Der Zugriff ist unzulässig, weilfer in Inner als private deklariert ist und der Zugriff nicht innerhalb der Klasse Inner erfolgt.
Aber der Zugriff darauf in InnerMostfist in Ordnung, weil dieser Zugriff innerhalb der Inner-Klasse erfolgt.
Java erlaubt beide Zugriffe, weil es äußeren Klassen erlaubt, auf private Mitglieder innerer Klassen zuzugreifen.
Protected-Mitglieder
In Scala ist der Zugriff auf protected-Mitglieder strenger als in Java. Es erlaubt nur, dass auf protected-Mitglieder in Unterklassen der Klasse zugegriffen wird, in der das Mitglied definiert ist. In Java kann auf Mitglieder, die mit dem protected-Schlüsselwort modifiziert wurden, von Unterklassen der Klasse, die das Mitglied definiert, sowie von anderen Klassen im selben Paket zugegriffen werden.
Beispiel
class Super {
protected def f() {println("f")}
}
class Sub extends Super {
f()
}
class Other {
(new Super).f() // Error
}
}
Im obigen Beispiel ist der Zugriff der Sub-Klasse auf f in Ordnung, weil 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, weil Other nicht von Super erbt. Letzteres ist auch in Java erlaubt, weil Other und Sub im selben Paket sind.
Public-Mitglieder
In Scala ist es standardmäßig public, wenn kein Modifizierer angegeben wird. Auf solche Mitglieder kann überall zugegriffen werden.
Beispiel
class Inner {
def f() { println("f") }
class InnerMost {
f() // Korrekt
}
}
(new Inner).f() // Korrekt, weil f() öffentlich ist
}
Paketprivater Zugriff
Scala unterstützt außerdem den paketprivaten Zugriffsmodifizierer, der Mitglieder darauf beschränkt, nur innerhalb eines bestimmten Pakets zugänglich zu sein. Dazu wird dem Schlüsselwort private ein Paketname nachgestellt. Das Format ist:
private[x] 或 protected[x]
Hier bezieht sichxauf das Paket, die Klasse oder das Singleton-Objekt, zu dem es gehört.
Wenn es alsprivate[x]geschrieben wird, liest es sich als"Dieses Mitglied ist für alle anderen Klassen privat, außer für die Klassen in […] oder die Klassen im Paket […] und deren Begleitobjekte."。
Diese Technik ist sehr nützlich in großen Projekten, die sich über mehrere Pakete erstrecken. Sie ermöglicht es Ihnen, Dinge zu definieren, die in mehreren Unterpaketen Ihres Projekts sichtbar sind, aber für Clients außerhalb des Projekts unsichtbar bleiben.
Beispiel
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
}
}
}
Im obigen Beispiel ist die Klasse Navigator als private[bobsrockets] markiert, was bedeutet, dass diese Klasse für alle Klassen und Objekte sichtbar ist, die im bobsrockets-Paket enthalten sind.
Zum Beispiel ist der Zugriff auf Navigator vom Vehicle-Objekt aus erlaubt, weil das Vehicle-Objekt im launch-Paket enthalten ist und das launch-Paket in bobsrockets liegt. Umgekehrt kann Code außerhalb des bobsrockets-Pakets nicht auf die Klasse Navigator zugreifen.
Begleitobjekte und Begleitklassen
In Scala können Begleitobjekte und Begleitklassen auf die privaten Mitglieder des jeweils anderen zugreifen. Ein Begleitobjekt und seine Begleitklasse sind eine Klasse und ein Objekt mit demselben Namen und in derselben Datei.
Beispiel
private val privateField: String = "Ich bin privat in der Klasse"
}
object CompanionExample {
def accessPrivateField(example: CompanionExample): String = {
example.privateField // Das Companion-Objekt kann auf die privaten Mitglieder der Klasse zugreifen
}
}
object Main {
def main(args: Array[String]): Unit = {
val example = new CompanionExample
println(CompanionExample.accessPrivateField(example))
}
}