Kompanionsobjekt i Scala

Lästid: 4 minuter

för att förstå användningen av kompanionsobjekt är det viktigt att förstå de statiska medlemmarna först. Vi har lärt oss att i objektorienterade språk är klasser planen som innehåller medlemmar som fält och metoder. Men för att komma åt dessa fält eller metoder måste vi först konstruera objekten från dessa klasser.

låt oss titta på ett exempel.

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

vi skapade en klass som heter matematik med en metod som kallas summa, som tar in två siffror och Returnerar summan som resultat.

för att utföra denna kod skapar vi en instans av denna Matematikklass och åberopade sum-metoden som kringgår 5 och 10 och tar emot 15 som utgång. Men som vi ser är summan metoden inte beroende av någon av medlemsvariablerna i Matematikklassen.

till exempel Max-medlemsvariabeln i detta fall. Så det borde inte finnas något behov av att skapa en instans av Matematikklass för att åberopa sum-metoden. Vi borde kunna ringa detta direkt i det här fallet. Och det är här följeslagare kommer in i bilden.

det finns fyra saker som vi måste komma ihåg om följeslagare:

1. De har samma namn som motsvarande klass.

2. De börjar med sökordet ”objekt”.

3. De bor i samma källfil som motsvarande klasser.

4. De medföljande objekten och motsvarande klasser fungerar som varandras privata medlemmar.

sökordet ”objekt” säger att detta är ett singleton-objekt. Med andra ord betyder det att medan ditt program körs kan du skapa så många instanser från dina klasser som du vill, men singleton-objektet skulle bara vara en, och det kommer inte att finnas flera instanser av det.

Låt oss se dem i aktion med vårt matematiska exempel.

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

som vi ser har vi skapat ett nytt singleton-objekt som heter Math, som har samma namn som vår klassmatematik. Det börjar också med sökordet” objekt ” och förblir i samma fil som klassmatematiken.

vi flyttade implementeringen för summan från klassen till dess följeslagare. Detta beror på att, som vi vet att summaimplementeringen inte är beroende av medlemsvariablerna för Matematikklassen, att sätta den implementeringen i följeslagarobjektet hjälper de som ringer att inte skapa instansen av Matematikklassen och ringa den direkt.

det finns en annan metod som vi har skrivit för att visa att följeslagarobjektet har tillgång till de privata medlemmarna i sin klass.

här instanser getPrivateMember Matematikklassen och returnerar den privat medlem med namnet”max”. Det finns ytterligare en sak att notera här. När vi definierar getPrivateMember satte vi inte parenteserna. I Scala finns det en konvention där om metoden inte har några argument att ta och inte utför någon bieffekt, vilket innebär att det är en ren funktion, kan vi välja att utelämna parenteserna.

här returnerar getPrivateMember bara värdet på medlemsvariabeln, så vi väljer att utelämna parenteserna.

Math.sum(5, 10)Math.getPrivateMember

när vi kör sum-metoden körde vi den från Math companion-objektet och behövde inte skapa den nya instansen av Math-klassen. Dessutom kunde vi komma åt den privata medlemsvariabeln i Math-klassen från companion-objektet.

skapa objekt med Apply

vi vet att för att skapa en ny instans av ett objekt måste vi använda det” nya ” nyckelordet.

till exempel:

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

vi har en klass som heter” Person ” med förnamn och efternamn som klassparametrar. Och vi skapar en ny instans av Person som visas ovan. Vi skapade ”alice” som en ny Person som passerade i förnamn och efternamn.

men i Scala finns det ytterligare ett sätt att skapa objekt utan att använda det nya sökordet.

det finns en metod som kallas” apply ” i companion object som behandlas speciellt av Scala-kompilatorn, och det låter oss skapa nya instanser av klasser utan att kräva det nya sökordet. Låt oss lära oss hur du använder den i vår kod.

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

som vi ser här har vi skapat ett följeslagarobjekt med tillämpa metod i det. Det tar argumenten att vi behöver skapa en instans av klassperson, det skapar instansen av Person internt och returnerar instansen. Som vi ser har vi skapat instansen av Personklass utan att använda det nya sökordet. Och vi kan komma åt medlemmarna precis som alla andra objekt.

det handlar om följeslagare objekt från den här bloggen. Fortsätt Lära, Fortsätt Växa!!!