Companion Object in Scala

Reading Time: 4 minutes

Per comprendere l’uso di oggetti companion, è importante comprendere prima i membri statici. Abbiamo imparato che nei linguaggi orientati agli oggetti, le classi sono il progetto che contiene membri come campi e metodi. Ma per accedere a questi campi o metodi, dobbiamo prima costruire gli oggetti da queste classi.

Diamo un’occhiata ad un esempio.

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

Abbiamo creato una classe chiamata Math con un metodo chiamato sum, che prende in due numeri e restituisce la somma come risultato.

Per eseguire questo codice, creiamo un’istanza di questa classe matematica e invochiamo il metodo sum bypassando 5 e 10, ricevendo 15 come output. Tuttavia, come vediamo, il metodo sum non dipende da nessuna delle variabili membro della classe Math.

Ad esempio, la variabile membro max in questo caso. Quindi, non dovrebbe essere necessario creare un’istanza di classe Matematica per invocare il metodo sum. Dovremmo essere in grado di chiamare questo direttamente in questo caso. Ed è qui che gli oggetti compagni entrano in scena.

Ci sono quattro cose che dobbiamo ricordare sugli oggetti companion:

1. Condividono lo stesso nome della classe corrispondente.

2. Iniziano con la parola chiave “oggetto”.

3. Vivono nello stesso file sorgente delle classi corrispondenti.

4. Gli oggetti companion e le classi corrispondenti agiscono come membri privati l’uno dell’altro.

La parola chiave “object” indica che si tratta di un oggetto singleton. In altre parole, significa che mentre il tuo programma è in esecuzione, puoi creare quante istanze dalle tue classi vuoi, ma l’oggetto singleton sarebbe solo uno e non ci saranno più istanze di esso.

Vediamoli in azione usando il nostro esempio matematico.

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

Come vediamo, abbiamo creato un nuovo oggetto singleton chiamato Math, che ha lo stesso nome della nostra classe Math. Inizia anche con la parola chiave “oggetto” e rimane nello stesso file della classe Math.

Abbiamo spostato l’implementazione per la somma dalla classe al suo oggetto compagno. Questo perché, poiché sappiamo che l’implementazione sum non dipende dalle variabili membro per la classe Math, inserire tale implementazione nell’oggetto companion aiuterà i chiamanti a non creare l’istanza della classe Math e chiamarla direttamente.

C’è un altro metodo che abbiamo scritto per mostrare che l’oggetto companion ha accesso ai membri privati della sua classe.

Qui getPrivateMember istanzia la classe Math e la restituisce membro privato chiamato “max”. C’è una cosa in più da notare qui. Quando definiamo getPrivateMember, non abbiamo messo le parentesi. In Scala, esiste una convenzione in cui se il metodo non ha argomenti da prendere e non esegue alcun effetto collaterale, il che significa che è una funzione pura, possiamo scegliere di omettere le parentesi.

Qui, getPrivateMember sta solo restituendo il valore della variabile membro, quindi scegliamo di omettere le parentesi.

Math.sum(5, 10)Math.getPrivateMember

Quando eseguiamo il metodo sum, lo abbiamo eseguito dall’oggetto Math companion e non abbiamo dovuto creare la nuova istanza della classe Math. Inoltre, siamo stati in grado di accedere alla variabile membro privato della classe Math dall’oggetto companion.

Creare oggetti usando Apply

Sappiamo che per creare una nuova istanza di un oggetto, dobbiamo usare la parola chiave “new”.

Per esempio:

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

Abbiamo una classe chiamata “Person” con il nome e cognome come parametri di classe. E creiamo una nuova istanza di Persona come mostrato sopra. Abbiamo creato “alice” come una nuova persona, passando il nome e il cognome.

Tuttavia, in Scala, c’è un altro modo per creare oggetti senza usare la nuova parola chiave.

Esiste un metodo chiamato “apply” nell’oggetto companion che viene trattato appositamente dal compilatore Scala e ci consente di creare nuove istanze di classi senza richiedere la nuova parola chiave. Impariamo come usarlo nel nostro codice.

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

Come vediamo qui, abbiamo creato un oggetto compagno con il metodo apply in esso. Prende gli argomenti di cui abbiamo bisogno per creare un’istanza di class Person, crea l’istanza di Person internamente e restituisce l’istanza. Come vediamo, abbiamo creato l’istanza della classe Person senza utilizzare la nuova parola chiave. E possiamo accedere ai membri proprio come qualsiasi altro oggetto. 🙂

Questo è tutto su Companion Object da questo blog. Continua a imparare, continua a crescere!!!