Scala 访问修饰符

Les modificateurs d'accès en Scala sont fondamentalement identiques à ceux de Java, ils sont : private, protected, public.

Si l'attribut de modificateur d'accès n'est pas spécifié, par défaut, le niveau d'accès des objets Scala est public.

Le qualificateur private en Scala est plus strict que dans Java, dans le cas des classes imbriquées, la classe externe ne peut même pas accéder aux membres privés de la classe imbriquée.

Membre privé (Private)

Modifié par le mot-clé private, les membres marqués de cette manière ne sont visibles qu'à l'intérieur de la classe ou de l'objet qui contient la définition de ces membres, et la même règle s'applique aux classes internes.

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

L'accès (new Inner).f() n'est pas légal car f Déclaré comme private dans Inner et l'accès n'est pas à l'intérieur de la classe Inner.

Mais en accédant depuis InnerMost f Il n'y a pas de problème, car cet accès est inclus dans la classe Inner.

Java permet ces deux types d'accès car il permet aux classes externes d'accéder aux membres privés des classes internes.

Membre protégé (Protected)

En Scala, l'accès aux membres protégés (Protected) est plus strict que dans Java. Car il n'autorise l'accès aux membres protégés que dans les sous-classes de la classe où ils sont définis. Dans Java, un membre protégé avec la clé protected peut être accédé non seulement par les sous-classes de la classe où il est défini, mais aussi par d'autres classes dans le même paquet.

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

Dans cet exemple, l'accès de Sub à f n'est pas un problème, car f est déclaré comme protected dans Super, et Sub est une sous-classe de Super. À l'inverse, l'accès d'Other à f n'est pas autorisé, car Other ne hérite pas de Super. Et cela est également reconnu en Java, car Other et Sub sont dans le même paquet.

Membre public (Public)

En Scala, si aucun modificateur n'est spécifié, il est par défaut public. Ces membres peuvent être accédés partout.

class Outer {
　　　class Inner {
　　　　　　def f() { println("f") }
　　　　　　class InnerMost {
　　　　　　　　　f()　//　Correct
　　　　　　}
　　　}
　　　(new Inner).f()　//　Correct car f() est public
}

Protection de portée

En Scala, les modificateurs d'accès peuvent être soulignés en utilisant des qualificatifs. La forme est :

private[x]　
ou　
protected[x]

Ici, x représente un paquet, une classe ou un objet singleton appartenant. Si il est écrit en tant que private[x], il est lu comme "Ce membre est private pour tous les autres classes, sauf pour les classes ou les paquets mentionnés dans [...] et leurs objets associés.

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

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。