Objeto compañero en Scala

Tiempo de lectura: 4 minutos

Para comprender el uso de objetos compañeros, es importante comprender primero los miembros estáticos. Hemos aprendido que en los lenguajes orientados a objetos, las clases son el modelo que contiene miembros, como campos y métodos. Pero para acceder a estos campos o métodos, primero necesitamos construir los objetos a partir de estas clases.

veamos un ejemplo.

class Math { private val max = 100 def sum(a: Int, b: Int): Int = a + b}object Test { def main(args: Array): Unit = { val math = new Math() math.sum(5, 10) }}

Creamos una clase llamada Math con un método llamado sum, que toma dos números y devuelve la suma como resultado.

Para ejecutar este código, creamos una instancia de esta clase matemática e invocamos el método sum sin pasar por 5 y 10, recibiendo 15 como salida. Sin embargo, como vemos, el método de suma no depende de ninguna de las variables miembro de la clase Matemática.

Por ejemplo, la variable miembro max en este caso. Por lo tanto, no debería haber necesidad de crear una instancia de clase de matemáticas para invocar el método sum. Deberíamos poder llamar a esto directamente en este caso. Y aquí es donde los objetos compañeros entran en la imagen.

Hay cuatro cosas que debemos recordar acerca de compañero de objetos:

1. Comparten el mismo nombre que la clase correspondiente.

2. Comienzan con la palabra clave» objeto».

3. Viven en el mismo archivo fuente que las clases correspondientes.

4. Los objetos compañeros y las clases correspondientes actúan como miembros privados de los demás.

La palabra clave «object» indica que se trata de un objeto único. En otras palabras, significa que mientras su programa se está ejecutando, puede crear tantas instancias de sus clases como desee, pero el objeto singleton sería solo uno, y no habrá varias instancias de él.

Vamos a verlos en acción usando nuestro ejemplo matemático.

object Math { def sum(a: Int, b: Int): Int = a + b def getPrivateMember: Int = = new Math().max}class Math { private val max = 100}object Test { def main(args: Array): Unit = { Math.sum(5, 10) Math.getPrivateMember }}

Como vemos, hemos creado un nuevo objeto único llamado Math, que tiene el mismo nombre que nuestra clase Math. También comienza con la palabra clave» object » y permanece en el mismo archivo que la clase Math.

Movimos la implementación de la suma de la clase a su objeto compañero. Esto se debe a que, como sabemos que la implementación sum no depende de las variables miembro de la clase Math, colocar esa implementación en el objeto acompañante ayudará a los llamantes a no crear la instancia de la clase Math y llamarla directamente.

Hay otro método que hemos escrito para mostrar que el objeto compañero tiene acceso a los miembros privados de su clase.

Aquí el getPrivateMember crea una instancia de la clase de matemáticas y la devuelve como miembro privado llamado «max». Hay una cosa adicional a tener en cuenta aquí. Cuando definimos el getPrivateMember, no pusimos los paréntesis. En Scala, hay una convención en la que si el método no tiene argumentos para tomar y no realiza ningún efecto secundario, lo que significa que es una función pura, podemos optar por omitir los paréntesis.

Aquí, getPrivateMember solo devuelve el valor de la variable miembro, por lo que elegimos omitir los paréntesis.

Math.sum(5, 10)Math.getPrivateMember

Cuando ejecutamos el método sum, lo ejecutamos desde el objeto Math companion y no tuvimos que crear la nueva instancia de la clase Math. Además, pudimos acceder a la variable miembro privado de la clase Math desde el objeto compañero.

Crear objetos Usando Apply

Sabemos que para crear una nueva instancia de un objeto, necesitamos usar la palabra clave «new».

Por ejemplo:

class Person(firstName: String, lastName: String) {def getName: String = firstName + lastName}object Test { def main(args: Array): Unit = { val alice = new Person("Alice", "Christy") }}

Tenemos una clase llamada «Persona» con el nombre y apellidos como parámetros de clase. Y creamos una nueva instancia de Persona como se muestra arriba. Creamos «alice» como una nueva Persona, pasando el nombre y el apellido.

Sin embargo, en Scala, hay una forma más de crear objetos sin usar la palabra clave nueva.

Hay un método llamado «apply» en el objeto acompañante que es tratado especialmente por el compilador Scala, y nos permite crear nuevas instancias de clases sin requerir la nueva palabra clave. Aprendamos a usarlo en nuestro código.

object Person { def apply(firstName: String, lastName: String): Person = new Person(firstName, lastName)}class Person(firstName: String, lastName: String) { def getName: String = firstName + " " + lastName}object Test { def main(args: Array): Unit = { val alice = Person("Alice", "Christy") println(p.getName) }}

Como vemos aquí, hemos creado un objeto complementario con el método apply en él. Toma los argumentos que necesitamos para crear una instancia de la clase Person, crea la instancia de Person internamente y devuelve la instancia. Como vemos, hemos creado la instancia de la clase Person sin usar la palabra clave new. Y podemos acceder a los miembros como a cualquier otro objeto. 🙂

Eso es todo sobre el objeto compañero de este blog. ¡Sigue Aprendiendo, Sigue Creciendo!!!