Modificateurs d'accès Scala
En Scala, les modificateurs d'accès sont utilisés pour contrôler la visibilité et les autorisations d'accès des classes, des objets, des traits et de leurs membres (tels que les champs et les méthodes).
Les modificateurs d'accès Scala sont essentiellement les mêmes que ceux de Java : private, protected et public.
Si aucun modificateur d'accès n'est spécifié, par défaut, le niveau d'accès de Scala est public.
Le qualificatif private en Scala est plus strict qu'en Java. Dans le cas de classes imbriquées, la classe externe ne peut même pas accéder aux membres private de la classe imbriquée.
Membres privés
Les membres marqués avec le mot-clé private ne sont visibles qu'à l'intérieur de la classe ou de l'objet qui contient la définition du membre. La même règle s'applique également aux classes internes.
Exemple
class Inner{
private def f(){
println("f")
}
class InnerMost{
f() // Correct
}
}
(new Inner).f() // Error
}
(new Inner).f( )L'accès est illégal carfil est déclaré private dans Inner, et l'accès ne se fait pas à l'intérieur de la classe Inner.
Mais y accéder dans InnerMostfest acceptable, car cet accès se fait à l'intérieur de la classe Inner.
Java autorise les deux accès parce qu'il permet aux classes externes d'accéder aux membres privés des classes internes.
Membres protégés
En Scala, l'accès aux membres protégés est plus strict qu'en Java. Il n'autorise l'accès aux membres protégés que dans les sous-classes de la classe où le membre est défini. En Java, les membres modifiés avec le mot-clé protected peuvent être accédés par les sous-classes de la classe qui définit le membre, ainsi que par d'autres classes du même package.
Exemple
class Super {
protected def f() {println("f")}
}
class Sub extends Super {
f()
}
class Other {
(new Super).f() // Erreur
}
}
Dans l'exemple ci-dessus, l'accès de la classe Sub à f est correct parce que f est déclaré protected dans Super, et Sub est une sous-classe de Super. En revanche, l'accès de Other à f n'est pas autorisé parce que Other n'hérite pas de Super. Ce dernier accès est également autorisé en Java parce que Other et Sub sont dans le même package.
Membres publics
En Scala, si aucun modificateur n'est spécifié, il est public par défaut. Ces membres sont accessibles partout.
Exemple
class Inner {
def f() { println("f") }
class InnerMost {
f() // Correct
}
}
(new Inner).f() // Correct car f() est public
}
Accès privé au package
Scala prend également en charge le modificateur d'accès privé au package, qui limite les membres à n'être accessibles qu'au sein d'un package spécifique. Cela se fait en faisant suivre le mot-clé private d'un nom de package. Le format est :
private[x] ou protected[x]
Ici,xfait référence au package, à la classe ou à l'objet singleton auquel il appartient.
Si écrit commeprivate[x], cela se lit comme« Ce membre est privé pour toutes les autres classes, sauf les classes de […] ou les classes du package […] et leurs objets compagnons. »。
Cette technique est très utile dans les grands projets qui s'étendent sur plusieurs packages. Elle vous permet de définir des éléments qui sont visibles dans plusieurs sous-packages de votre projet mais restent invisibles pour les clients extérieurs au projet.
Exemple
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
}
}
}
Dans l'exemple ci-dessus, la classe Navigator est marquée comme private[bobsrockets], ce qui signifie que cette classe est visible par toutes les classes et tous les objets contenus dans le paquet bobsrockets.
Par exemple, l'accès à Navigator depuis l'objet Vehicle est autorisé car l'objet Vehicle est contenu dans le paquet launch, et le paquet launch se trouve dans bobsrockets. Inversement, tout code extérieur au paquet bobsrockets ne peut pas accéder à la classe Navigator.
Objets compagnons et classes compagnes
En Scala, les objets compagnons et les classes compagnes peuvent accéder aux membres privés les uns des autres. Un objet compagnon et sa classe compagne sont une classe et un objet portant le même nom et dans le même fichier.
Exemple
private val privateField: String = "Je suis privé dans la classe"
}
object CompanionExample {
def accessPrivateField(example: CompanionExample): String = {
example.privateField // L'objet compagnon peut accéder aux membres privés de la classe
}
}
object Main {
def main(args: Array[String]): Unit = {
val example = new CompanionExample
println(CompanionExample.accessPrivateField(example))
}
}