Alcance del método de control en Scala

Como sugiere el nombre, los modificadores de acceso en Scala ayudan a restringir el alcance de una clase, variable, método o miembro de datos. Controlar el alcance del método En Scala ayuda a restringir el alcance del método o miembro de datos. Hay cinco tipos de alcance del método de control en Scala:

1. Alcance público
2. Ámbito privado
3. Ámbito protegido
4. Ámbito de objeto privado
5. Específico del paquete

• Cuando no se especifica ningún modificador de acceso para una clase, método o miembro de datos, se dice que tiene el modificador de acceso predeterminado de forma predeterminada.
• Los miembros de datos, la clase o los métodos que no se declaran utilizando ningún modificador de acceso, es decir, que tienen un modificador de acceso predeterminado, son accesibles en cualquier lugar mediante el uso de paquetes e importaciones o mediante la creación de nuevas instancias.
  Ejemplo :

  // Scala program of Public Scope // package testA class classA {     def method1(): Unit=     {         println("method1")     } }    // Creating object object GfG {      // Main method     def main(args: Array[String])     {         // classA in the same package          // as the main method          var x = new classA         x.method1()     } }

  Producción :

  method1
  

  Ejemplo :

• El modificador privado es el mismo que privado en Java. Al marcar un método o variable como privado, está disponible para la clase actual y sus miembros y cualquiera de las instancias de la misma clase.
• Cualquier otro objeto/clase del mismo paquete no podrá acceder a los miembros privados.
• Esto se hace usando el modificador de acceso privado .

  Ejemplo :

  // Scala program of Private Scope // package testA class classA  {     var x = 1     private def method1: Unit =     {         println("method1")     } }    // Creating object object GfG {     // Main method     def main(arg: Array[String])     {         var obj1 = new classA         printf("x = "+obj1.x)         // println(obj1.method1) error: method          // method1 in class classA cannot          // be accessed in classA     } }

  Producción:

  x = 1
  

• Scala protected es diferente de protected en java. Para marcar un miembro protegido, use la palabra clave protected antes de una clase o variable.
• Solo las subclases del mismo paquete pueden acceder a los miembros protegidos.
  Ejemplo :

  // Scala program of Protected Scope // package test class classab {     protected var ab: Int=4     var ad: Int =1 }    // Creating object object GfG extends classab {      // sub class     // Main method     def main(args: Array[String])     {         println(ab) //can be accessed         println(ad) //can be accessed     } }

  Producción:

  4
  1
  

• Los miembros protegidos no pueden ser accedidos por otros miembros en otros paquetes, incluso con importaciones.
  Ejemplo :

  // Scala program of Protected Scope // package testA package testA {     class classA      {         protected var ab: Int=4         var ad: Int =1     } }    // another package testB package testB {     // importing all the members      // from testA package     import testA._            // Creating object     object GfG     {         // Main method         def main(args: Array[String])         {             var ta= new classA             ta.ad             ta.ab //error         }     } }

  Producción:

  error: no se puede acceder a la variable ab en la clase classA en testA.classA No se permite el
  acceso al método protegido ab porque
  el objeto adjunto GfG en el paquete testB no es una subclase de
  la clase classA en el paquete testA donde el objetivo está definido
  ta.ab //error
  ^
  uno error encontrado

• El objeto privado es lo mismo que privado, la única diferencia es que el objeto privado declarado miembro estará disponible solo desde donde se define el miembro, es decir, ningún objeto puede acceder a él, por lo tanto, se llama objeto privado.
• El objeto protegido es lo mismo que protegido, la única diferencia es que el miembro solo estará disponible en el que está definido o para las subclases y no estará disponible para los objetos.
• Para marcar un objeto miembro como privado, use las palabras clave private[this] .
• Para marcar un objeto miembro protegido, use las palabras clave protected[this] , donde this se refiere o apunta al objeto actual.

  Ejemplo :

  // Scala program of Object Private/Protected Scope // package test1.test11 class class11  {     private[this] var x = 1     private var t = 2     var z = 3     def method11(other: class11): Unit =     {         println(x)         println(t)         println(z)                    // println(other.x)         println(other.t)         println(other.z)     } } // here on line14 x can only be // accessed from inside in which  // it is defined    // Creating object object GfG {     // Main method     def main(arg: Array[String])     {         var obj11 = new class11() //current instance created         var y = 2         println(obj11.method11(obj11))         println(obj11.z)         //println(obj11.t) //error: t cannot be accessed         //println(obj11.x) //error: x is not a member of class11         //according to obj11 x is not a member     } }

  Producción :

  1
  2
  3
  2
  3
  ()
  3
  

• Cuando queremos que un miembro esté disponible para un paquete completo. Se trata de declarar ese miembro como privado[nombre_del_paquete] .
• Todos los miembros dentro del paquete pueden acceder a ese miembro.
• Se puede acceder a los miembros mediante cualquier otro paquete cuyo nombre se esté calificando.
  Ejemplo :

  // Scala program of Package Specific // Scala program of Package Specific package aa class geek {     class g1     {           // inner class         // private to class g1         private var a = 0                     // available to package aa         private[aa] var b = 0          def method()         {             a = a + 1             b = b + 1             println("welcome to inner class g1")             println("a= "+a)         }     } }     // Creating object object Main {     // Driver code     def main(args: Array[String])     {         val obj = new geek()         val o = new obj.g1         o.method();         println("b= "+o.b);     } }

Producción :

welcome to inner class g1
a= 1
b= 1