Paquetes En Scala

Package en Scala es un mecanismo para encapsular un grupo de clases, subpaquetes, rasgos y objetos de paquete. Básicamente proporciona un espacio de nombres para poner nuestro código en diferentes archivos y directorios. Packages es una manera fácil de mantener nuestro código que evita conflictos de nombres de miembros de diferentes paquetes. Proporcionar control de acceso a los miembros de paquetes como privado, protegido, alcance de control específico del paquete restringe el acceso del miembro a otros paquetes, mientras que los miembros sin modificador se pueden usar dentro de cualquier otro paquete con alguna referencia.

Declaración de paquete

Los paquetes se declaran como una primera declaración en la parte superior de un archivo Scala.
Sintaxis:

package package_name
// Scala classes
// traits
// objects..

La definición de un paquete se puede hacer de diferentes maneras: –

• métodos enstringdos

  package x.y.z
  // members of z
  

  o se puede utilizar como: –

  package x
  package y
  package z
  // member of z
  

• Paquetes de anidamiento

  package x{
     // members of x {as required}
     package y{
        // members of y{as required}
        package z{
           // members of z{as required}
        }
     }
  }
  

Cómo funciona el paquete

Los paquetes unen los datos en un solo archivo o funcionan como encapsulación de datos, cuando se guarda un archivo, se incluye en el paquete predeterminado o en un nombre de paquete como se especifica en la parte superior del archivo. Los nombres de los paquetes y la estructura de directorios están estrechamente relacionados. Por ejemplo, si el nombre de un paquete es college.student.cse, habrá 3 directorios, college, student y cse. Tal que cse está presente en estudiante y estudiante está presente en universidad.

college
     +student
          +cse

La idea es asegurarse de que los archivos sean fáciles de ubicar en los directorios mientras se usan los paquetes.
Las convenciones de nomenclatura de paquetes para nombres de dominio están en orden inverso, es decir, org.geeksforgeeks.practice, org.geeksforgeeks.contribute.

Adición de miembros a paquetes

Podemos agregar cualquier cantidad de miembros en un paquete, como clases, subclases, rasgos, objetos que contienen el método principal y subpaquetes. A diferencia de los paquetes Java, podemos agregar paquetes declarados en diferentes archivos Scala, es decir, se pueden escribir diferentes archivos Scala para el mismo paquete.
Ejemplo:

// file named as faculty.scala
package college
class faculty{
   def faculymethod(){}
}

// file named as student.scala
// containing the main method
  
// using the college package name again
package college 
class student
{
    def studentmethod(){}
} 
  
// Creating object
object Main
{
  
    // Main method
    def main(args: Array[String])
    {
        val stu= new student()
        val fac= new faculty() 
        // faculty class can be accessed while
        // in different file but in same package.
    }
}

Lo que realmente se crea en la estructura de directorios es el siguiente:

college
     +faculty.scala
     +student.scala

Uso de paquetes

Los paquetes se pueden usar de diferentes maneras en un programa. Las cláusulas de importación son bastante flexibles en Scala que en Java. Por ejemplo, las cláusulas de importación se pueden usar en cualquier parte del programa como una declaración independiente en el programa usando la palabra clave import , Java no lo permite.

// base.scala
// bb directory
package bb 
  
// creating a class
class geek
{ 
    private var id=0
    def method()
    {
        println("welcome to geek class")
        println("id="+id)
    }
} 

A continuación se muestra el ejemplo de Paquete que utiliza cláusulas de importación.

// main.scala
// aa directory
package aa 
  
// Creating object
object Main
{
    // Main method
    def main(args: Array[String])
    {
        // importing in main method
        import bb.geek 
          
        // using the member injected using import statement
        val obj = new geek() 
        obj.method();
    }
}

Diferentes formas de usar sentencias de importación

• Importación de todos los miembros públicos del paquete.

  import college._
  //imports all college members students, faculties, houseKeeping etc.
  

• Importa solo miembros seleccionados de un paquete.

  import college.{faculty, houseKeeping}
  //member student is not selected hence cannot be used in current file
  

• Importa y cambia el nombre de los miembros.

  import college.{student => stu}
  //stu is used in-place of student