Scala Language
Portée

Introduction

Syntaxe

• déclaration
• déclaration privée
• privé [cette] déclaration
• déclaration privée [fromWhere]
• déclaration protégée
• déclaration protégée [fromWhere]

Portée publique (par défaut)

Par défaut, la portée est public , la valeur est accessible depuis n'importe où.

package com.example {
  class FooClass {
    val x = "foo"
  }
}

package an.other.package {
  class BarClass {
    val foo = new com.example.FooClass
    foo.x // <- Accessing a public value from another package
  }
}

Un champ privé

Lorsque l'étendue est privée, vous ne pouvez y accéder qu'à partir de la classe en cours ou d'autres instances de la classe en cours.

package com.example {
  class FooClass {
    private val x = "foo"
    def aFoo(otherFoo: FooClass) {
      otherFoo.x // <- Accessing from another instance of the same class
    }
  }
  class BarClass {
    val f = new FooClass
    f.x // <- This will not compile
  }
}

Une portée spécifique au package privé

Vous pouvez spécifier un package dans lequel la valeur privée est accessible.

package com.example {
  class FooClass {
    private val x = "foo"
    private[example] val y = "bar"
  }
  class BarClass {
    val f = new FooClass
    f.x // <- Will not compile
    f.y // <- Will compile
  }
}

Portée privée de l'objet

La portée la plus restrictive est la portée "object-private" , qui autorise uniquement l'accès à cette valeur à partir de la même instance de l'objet.

class FooClass {
  private[this] val x = "foo"
  def aFoo(otherFoo: FooClass) = {
    otherFoo.x // <- This will not compile, accessing x outside the object instance
  }
}

Portée protégée

La portée protégée permet d'accéder à la valeur depuis n'importe quelle sous-classe de la classe en cours.

class FooClass {
  protected val x = "foo"
}
class BarClass extends FooClass {
  val y = x // It is a subclass instance, will compile
}
class ClassB {
  val f = new FooClass
  f.x // <- This will not compile
}

Portée protégée du package

La portée protégée par le package permet d'accéder à la valeur uniquement à partir de n'importe quelle sous-classe d'un package spécifique.

package com.example {
  class FooClass {
    protected[example] val x = "foo"
  }
  class ClassB extends FooClass {
    val y = x // It's in the protected scope, will compile
  }
}
package com {
  class BarClass extends com.example.FooClass {
    val y = x // <- Outside the protected scope, will not compile
  }
}