Modificateurs d'accès Scala
Les modificateurs d'accès Scala sont fondamentalement les mêmes que ceux de Java, notamment : privé, protégé et public.
Si aucun modificateur d'accès n'est spécifié, le niveau d'accès des objets Scala est public par défaut.
Le qualificatif privé en Scala est plus strict que Java. Dans le cas de classes imbriquées, la classe externe ne peut même pas accéder aux membres privés de la classe imbriquée.
Les membres privés
sont modifiés avec le mot-clé privé. Les membres avec cette balise ne sont visibles qu'à l'intérieur de la classe ou de l'objet qui contient la définition de membre. Les mêmes règles s'appliquent également à la classe interne.
class Outer{
class Inner{
private def f(){println("f")}
class InnerMost{
f() // 正确
}
}
(new Inner).f() //错误
}(new Inner).f() L'accès est illégal car f est déclaré comme privé dans Inner et l'accès ne se fait pas dans la classe Inner.
Mais il n'y a aucun problème pour accéder à f dans InnerMost, car cet accès est inclus dans la classe Inner.
Les deux types d'accès sont autorisés en Java car ils permettent 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. Parce qu'il permet uniquement d'accéder aux membres protégés dans les sous-classes de la classe dans laquelle le membre est défini. En Java, les membres modifiés avec le mot-clé protected sont accessibles non seulement par les sous-classes de la classe qui définit le membre, mais également par les autres classes du même package.
package p{
class Super{
protected def f() {println("f")}
}
class Sub extends Super{
f()
}
class Other{
(new Super).f() //错误
}
}Dans l'exemple ci-dessus, la classe Sub n'a aucun problème à accéder à f car f est déclaré protégé dans Super, et Sub est une sous-classe de Super. En revanche, l'accès d'Autre à f n'est pas autorisé car autre n'hérite pas de Super. Ce dernier est également reconnu en Java, car Other et Sub sont dans le même package.
Membre public
Dans Scala, si aucun modificateur n'est spécifié, il est par défaut public. Ces membres sont accessibles de n’importe où.
class Outer {
class Inner {
def f() { println("f") }
class InnerMost {
f() // 正确
}
}
(new Inner).f() // 正确因为 f() 是 public
}Protection de la portée
Dans Scala, les modificateurs d'accès peuvent être soulignés à l'aide de qualificatifs. Le format est :
private[x] 或 protected[x]
Le x ici fait référence à un certain package, classe ou objet singleton. S'il est écrit comme private[x], il se lit comme "Ce membre est privé pour toutes les autres classes à l'exception des classes de [...] ou des classes du package dans [...] et de 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 quelque chose qui est visible dans plusieurs sous-packages de votre projet mais qui est toujours invisible pour les clients extérieurs au projet
package bobsrocckets{
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 privée [bobsrockets], ce qui signifie que cette classe est visible par toutes les classes et objets contenus dans le package bobsrockets Par exemple, Navigator est visible depuis le véhicule. L'accès est autorisé car l'objet Vehicle est contenu dans le package de lancement et le package de lancement est dans bobsrockets. En revanche, tout le code en dehors du package bobsrockets ne peut pas accéder à la classe Navigator.
