Modificadores de Acesso Scala

Os modificadores de acesso no Scala são basicamente iguais aos do Java, respectivamente: private, protected, public.

Se o modificador de acesso não for especificado, o nível de acesso padrão para objetos Scala é público.

O modificador private no Scala é mais rigoroso do que no Java, no caso de classes aninhadas, a classe externa nem pode acessar os membros privados da classe aninhada.

Membro Privado (Private)

Modificada com a palavra-chave private, os membros marcados com este sinal são visíveis apenas dentro da classe ou objeto que contém a definição do membro, e a mesma regra se aplica às classes internas.

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

O acesso (new Inner).f() não é permitido porque f foi declarado como private em Inner e o acesso não está dentro da classe Inner.

mas ao acessar em InnerMost f Não há problema, pois esse acesso está dentro da classe Inner.

O Java permite esses dois tipos de acesso porque permite que classes externas acessem membros privados de classes internas.

Membros protegidos (Protected)

No Scala, o acesso a membros protegidos é mais rigoroso do que no Java. Isso porque ele permite que membros protegidos sejam acessados apenas por subclasses que definiram o membro. No Java, membros protegidos marcados com protected podem ser acessados por subclasses que definiram o membro, bem como por outras classes no mesmo pacote.

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

No exemplo, a Sub classe não tem problema ao acessar f, porque f foi declarado como protected em Super e Sub é subclasse de Super. Por outro lado, o acesso de Other a f não é permitido, porque Other não herda de Super. Isso também é aceito no Java, porque Other e Sub estão no mesmo pacote.

Membros públicos (Public)

No Scala, se nenhum modificador for especificado, o padrão é public. Este membro pode ser acessado em qualquer lugar.

class Outer {
　　　class Inner {
　　　　　　def f() { println("f") }
　　　　　　class InnerMost {
　　　　　　　　　f()　//　Correto
　　　　　　}
　　　}
　　　(new Inner).f()　//　Correto porque f() é público
}

Proteção de escopo

No Scala, os modificadores de acesso podem ser enfatizados usando quantificadores. A forma é:

private[x]　
ou　
protected[x]

Aqui, x representa um pacote, classe ou objeto singleton pertencente. Se escrito como private[x], lê-se: "Este membro é private além da classe [...] ou do pacote [...] da classe e seus objetos associados, para todas as outras classes.

Essa técnica é muito útil em grandes projetos que cruzam vários pacotes, permitindo definir coisas que são visíveis em várias subpastas do seu projeto, mas sempre invisíveis para clientes externos ao projeto.

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
　　　　　　　　}
　　　　}
}

Neste exemplo, a classe Navigator é marcada como private[bobsrockets], o que significa que esta classe é visível para todos os tipos e objetos contidos no pacote bobsrockets.

Por exemplo, o acesso a Navigator do objeto Vehicle é permitido, pois o objeto Vehicle está incluído no pacote launch, e o launch está incluído em bobsrockets, ao contrário, todo o código fora do pacote bobsrockets não pode acessar a classe Navigator.