Companion Object in Scala

Leestijd: 4 minuten

om het gebruik van companion objects te begrijpen, is het belangrijk om eerst de statische leden te begrijpen. We hebben geleerd dat in objectgeoriënteerde talen klassen de blauwdruk zijn die leden zoals velden en methoden bevat. Maar om toegang te krijgen tot deze velden of methoden, moeten we eerst de objecten uit deze klassen te construeren.

laten we een voorbeeld bekijken.

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

we maakten een klasse genaamd Math met een methode genaamd sum, die twee getallen opneemt en de som als resultaat retourneert.

om deze code uit te voeren, maken we een instantie van deze Wiskundeklasse en roepen we de sommethode aan die 5 en 10 omzeilt en 15 als uitvoer ontvangt. Echter, zoals we zien, de som methode is niet afhankelijk van een van de leden variabelen van de wiskunde klasse.

bijvoorbeeld, de max member variabele in dit geval. Er zou dus geen noodzaak moeten zijn om een instantie van wiskundeles te maken om de sommethode aan te roepen. We zouden dit in dit geval direct moeten kunnen noemen. En dit is waar de metgezelobjecten in beeld komen.

er zijn vier dingen die we moeten onthouden over metgezelobjecten:

1. Ze hebben dezelfde naam als de bijbehorende klasse.

2. Ze beginnen met het” object ” sleutelwoord.

3. Ze leven in hetzelfde bronbestand als de bijbehorende klassen.

4. De metgezelobjecten en de bijbehorende klassen fungeren als elkaars privé-leden.

het trefwoord” object ” vertelt dat dit een singleton-object is. Met andere woorden, het betekent dat terwijl uw programma draait, kunt u zo veel instanties van uw klassen als je wilt maken, maar de singleton object zou slechts één, en er zullen niet meerdere instanties van het.

laten we ze in actie zien met ons wiskundige voorbeeld.

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

zoals we zien, hebben we een nieuw singleton object genaamd Math aangemaakt, dat dezelfde naam heeft als onze class Math. Het begint ook met het” object ” trefwoord en blijft in hetzelfde bestand als de Class Math.

We hebben de implementatie voor de som verplaatst van de klasse naar het bijbehorende object. Dit is omdat, omdat we weten dat de sum implementatie niet afhankelijk is van de Member variabelen voor de Math class, het plaatsen van die implementatie in het companion object zal helpen de bellers om niet de instantie van Math class te maken en direct aan te roepen.

er is een andere methode die we hebben geschreven om aan te tonen dat het companion object toegang heeft tot de privé-leden van zijn klasse.

hier instantieert het getPrivateMember de Math class en retourneert het privé lid met de naam”max”. Er is nog een ding om op te merken. Wanneer we het getPrivateMember definiëren, hebben we de haakjes niet gezet. In Scala is er een conventie waarin als de methode geen argumenten heeft om te nemen en geen neveneffect heeft, wat betekent dat het een pure functie is, we kunnen kiezen om de haakjes weg te laten.

hier retourneert getPrivateMember alleen de waarde van de Member variabele, dus kiezen we ervoor om de haakjes weg te laten.

Math.sum(5, 10)Math.getPrivateMember

wanneer we de sum methode uitvoeren, voerden we het uit vanuit het Math companion object en hoefden we niet de nieuwe instantie van Math class aan te maken. Daarnaast waren we in staat om toegang te krijgen tot de variabele privé lid van de wiskundeles van het companion object.

objecten maken met Apply

We weten dat om een nieuwe instantie van een object te maken, we het” nieuwe ” sleutelwoord moeten gebruiken.

bijvoorbeeld:

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

we hebben een klasse genaamd” persoon ” met de voornaam en achternaam als klasse parameters. En we maken een nieuwe instantie van persoon zoals hierboven getoond. We creëerden “alice” als een nieuwe persoon, passeren in de voor-en achternaam.

in Scala is er echter nog een manier om objecten te maken zonder het nieuwe sleutelwoord te gebruiken.

er is een methode genaamd” apply ” in companion object die speciaal wordt behandeld door de Scala compiler, en het laat ons nieuwe instanties van klassen maken zonder dat het nieuwe sleutelwoord nodig is. Laten we leren hoe het te gebruiken in onze 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) }}

zoals we hier zien, hebben we een metgezel object gemaakt met de methode toepassen erin. Het neemt de argumenten die we nodig hebben om een instantie van klasse persoon te creëren, het creëert de instantie van persoon intern, en geeft de instantie terug. Zoals we zien, hebben we de instantie van persoon klasse gemaakt zonder gebruik te maken van het nieuwe trefwoord. En we kunnen toegang krijgen tot de leden, net als elk ander object. 🙂

dat is alles over Companion Object van deze blog. Blijf Leren, Blijf Groeien!!!