Scala Language
Scopo

introduzione

Sintassi

• dichiarazione
• dichiarazione privata
• [questa] dichiarazione privata
• dichiarazione privata [fromWhere]
• dichiarazione protetta
• protetta [daWhere] dichiarazione

Ambito pubblico (predefinito)

Per impostazione predefinita, l'ambito è public , il valore è accessibile da qualsiasi luogo.

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 ambito privato

Quando l'ambito è privato, è possibile accedervi solo dalla classe corrente o da altre istanze della classe corrente.

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

Un ambito specifico del pacchetto privato

È possibile specificare un pacchetto in cui è possibile accedere al valore privato.

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

Scopo privato dell'oggetto

L'ambito più restrittivo è l'ambito "oggetto-privato" , che consente di accedere a tale valore solo dalla stessa istanza dell'oggetto.

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

Ambito protetto

L'ambito protetto consente l'accesso al valore da qualsiasi sottoclasse della classe corrente.

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
}

Ambito protetto da pacchetto

L'ambito protetto del pacchetto consente di accedere al valore solo da qualsiasi sottoclasse in un pacchetto specifico.

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