Objet compagnon dans Scala

Temps de lecture: 4 minutes

Afin de comprendre l’utilisation des objets compagnons, il est important de comprendre d’abord les membres statiques. Nous avons appris que dans les langages orientés objet, les classes sont le plan qui contient des membres tels que des champs et des méthodes. Mais pour accéder à ces champs ou méthodes, nous devons d’abord construire les objets à partir de ces classes.

Regardons un exemple.

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

Nous avons créé une classe appelée Math avec une méthode appelée sum, qui prend deux nombres et renvoie la somme comme résultat.

Pour exécuter ce code, nous créons une instance de cette classe mathématique et invoquons la méthode sum en contournant 5 et 10, en recevant 15 en sortie. Cependant, comme nous le voyons, la méthode de somme ne dépend d’aucune des variables membres de la classe de mathématiques.

Par exemple, la variable membre max dans ce cas. Il ne devrait donc pas être nécessaire de créer une instance de classe Math pour invoquer la méthode sum. Nous devrions pouvoir appeler cela directement dans ce cas. Et c’est là que les objets compagnons entrent en scène.

Il y a quatre choses dont nous devons nous souvenir à propos des objets compagnons :

1. Ils partagent le même nom que la classe correspondante.

2. Ils commencent par le mot-clé « objet ».

3. Ils vivent dans le même fichier source que les classes correspondantes.

4. Les objets compagnons et les classes correspondantes agissent en tant que membres privés les uns des autres.

Le mot clé « object » indique qu’il s’agit d’un objet singleton. En d’autres termes, cela signifie que pendant l’exécution de votre programme, vous pouvez créer autant d’instances à partir de vos classes que vous le souhaitez, mais l’objet singleton ne serait qu’un seul, et il n’y en aura pas plusieurs instances.

Voyons-les en action en utilisant notre exemple mathématique.

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

Comme nous le voyons, nous avons créé un nouvel objet singleton appelé Math, qui porte le même nom que notre classe Math. Il commence également par le mot-clé « objet » et reste dans le même fichier que la classe Math.

Nous avons déplacé l’implémentation de la somme de la classe vers son objet compagnon. En effet, comme nous savons que l’implémentation de sum ne dépend pas des variables membres de la classe Math, mettre cette implémentation dans l’objet compagnon aidera les appelants à ne pas créer l’instance de la classe Math et à l’appeler directement.

Il existe une autre méthode que nous avons écrite pour montrer que l’objet compagnon a accès aux membres privés de sa classe.

Ici, getPrivateMember instancie la classe de mathématiques et la renvoie un membre privé nommé « max ». Il y a une chose supplémentaire à noter ici. Lorsque nous définissons le getPrivateMember, nous n’avons pas mis les parenthèses. Dans Scala, il existe une convention dans laquelle si la méthode n’a aucun argument à prendre et n’effectue aucun effet secondaire, ce qui signifie que c’est une fonction pure, nous pouvons choisir d’omettre les parenthèses.

Ici, getPrivateMember renvoie simplement la valeur de la variable membre, nous choisissons donc d’omettre les parenthèses.

Math.sum(5, 10)Math.getPrivateMember

Lorsque nous exécutons la méthode sum, nous l’exécutons à partir de l’objet Math companion et n’avons pas eu à créer la nouvelle instance de la classe Math. De plus, nous avons pu accéder à la variable membre privée de la classe de mathématiques à partir de l’objet compagnon.

Création d’objets En utilisant Apply

Nous savons que pour créer une nouvelle instance d’un objet, nous devons utiliser le mot clé « new ».

Par exemple:

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

Nous avons une classe appelée « Person » avec le prénom et le nom comme paramètres de classe. Et nous créons une nouvelle instance de Person comme indiqué ci-dessus. Nous avons créé « alice » en tant que nouvelle personne, en transmettant le prénom et le nom de famille.

Cependant, dans Scala, il existe un autre moyen de créer des objets sans utiliser le nouveau mot-clé.

Il existe une méthode appelée « apply » dans l’objet compagnon qui est traitée spécialement par le compilateur Scala, et elle nous permet de créer de nouvelles instances de classes sans nécessiter le nouveau mot-clé. Apprenons à l’utiliser dans notre code.

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

Comme nous le voyons ici, nous avons créé un objet compagnon avec la méthode apply dedans. Il prend les arguments dont nous avons besoin pour créer une instance de classe Person, il crée l’instance de Person en interne et renvoie l’instance. Comme nous le voyons, nous avons créé l’instance de la classe Person sans utiliser le nouveau mot clé. Et nous pouvons accéder aux membres comme n’importe quel autre objet. 🙂

C’est tout au sujet de l’objet compagnon de ce blog. Continuez À Apprendre, Continuez à Grandir!!!