Share
Kotlin är ett modernt programmeringsspråk som kompilerar till Java bytecode. Det är gratis och öppen källkod, och lovar att göra kodning för Android ännu roligare.
I den föregående artikeln lärde du dig avancerad användning av funktioner, som tilläggsfunktioner, stängningar, högre orderfunktioner och inlinefunktioner i Kotlin.
I det här inlägget får du en introduktion till objektorienterad programmering i Kotlin genom att lära dig om klasser: konstruktörer och egenskaper, gjutning och avancerade klassfunktioner som Kotlin lätt gör.
En klass är en programenhet som grupperar funktioner och data för att utföra vissa relaterade uppgifter. Vi förklarar en klass i Kotlin med hjälp av klass sökord som liknar Java.
klassbok
Den föregående koden är den enklaste klassdeklarationen - vi har precis skapat en tom klass som heter bok. Vi kan fortfarande instansera den här klassen även om den inte innehåller en kropp med sin standardkonstruktor.
val bok = bok ()
Som du kan observera i koden ovan använde vi inte ny sökord för att ordna den här klassen - vilket är vanligt i andra programmeringsspråk. ny är inte ett nyckelord i Kotlin. Detta gör vår källkod konsekvent när du skapar en klassinstans. Men var medveten om att inställning av en Kotlin-klass i Java kommer att kräva ny nyckelord.
// I en Java-fil Bokbok = Ny bok ()
Låt oss titta på hur man lägger till en konstruktör och egenskaper i vår klass. Men först, låt oss se en typisk klass i Java:
/ * Java * / public class Boka privat String title; privat Long isbn; allmän bok (String title, Long isbn) this.title = title; this.isbn = isbn; Offentlig String getTitle () Retur titel; public void setTitle (String title) this.title = title; offentliga Long getIsbn () return isbn; public void setIsbn (Long isbn) this.isbnbn = isbn;
Titta på vår bok modell klass ovan har vi följande:
Accentsconagua
titel och isbn Låt oss nu titta på hur vi kan skriva den föregående koden i Kotlin istället:
/ * Kotlin * / klassboken var titel: String var isbn: Långkonstruktör (titel: String, isbn: Lång) this.title = title this.isbn = isbn
En ganska snygg klass! Vi har nu minskat antalet linjer med kod från 20 till bara 9. The konstruktör() funktion kallas a sekundärkonstruktor i Kotlin. Denna konstruktör motsvarar den Java-konstruktör som vi ringde vid instansiering av en klass.
I Kotlin finns inget begrepp på ett fält som du kanske känner till; istället använder den begreppet "egenskaper". Till exempel har vi två mutable (read-write) egenskaper som deklarerats med var nyckelord: titel och isbn i bok klass. (Om du behöver en uppdatering på variabler i Kotlin, vänligen besök första inlägget i denna serie: Variabler, Grundtyper och Arrays).
En fantastisk sak är att getters och setters för dessa egenskaper genereras automatiskt för oss under huven av Kotlin-kompilatorn. Observera att vi inte angav några siktmodifierare till dessa egenskaper, så de är vanligtvis offentliga. Med andra ord kan de nås från var som helst.
Låt oss titta på en annan version av samma klass i Kotlin:
klassbokkonstruktör (titel: String, isbn: Long) var titel: String var isbn: Long init this.title = title this.isbn = isbn
I den här koden har vi tagit bort den sekundära konstruktorn. I stället förklarade vi en konstruktör i klasshuvudet som heter a primärkonstruktor. En primärkonstruktör har ingen plats att lägga in ett block av kod, så vi utnyttjar i det modifierare för att initialisera inkommande parametrar från den primära konstruktorn. Observera att i det kodblock utförs omedelbart när klassen förekomst skapas.
Som du kan se har vår kod fortfarande mycket kokkärl. Låt oss minska det ytterligare:
klassbokkonstruktör (var titel: String, var isbn: Lång)
Vår bok klassen är nu bara en rad kod. Det är verkligen coolt! Observera att vi i parametern för primärkonstruktor definierade våra muterbara egenskaper: titel och isbn direkt inuti den primära konstruktören med var nyckelord.
Vi kan också lägga till standardvärden i någon av klassegenskaperna direkt inom konstruktorn.
klassbokkonstruktor (var titel: String = "standardvärde", var isbn: Lång)
Faktum är att vi också kan utelämna konstruktör sökord, men bara om det inte har någon siktmodifierare (offentlig, privat, eller skyddad) eller några kommentarer.
klassbok (var titel: String = "standardvärde", var isbn: Långt)
En väldigt snygg klass, jag måste säga!
Vi kan nu skapa en klassinstans så här:
val bok = Bok ("En sang av is och eld", 9780007477159) val book2 = Bok (1234) // använder titelföreningens standardvärdeI Kotlin kan vi få en egendom av klassobjektet bok, följt av en punktseparator ., sedan egenskapsnamnet titel. Denna korta stil med tillgång till egenskaper kallas syntax för egendomstillträde. Med andra ord behöver vi inte ringa egenskaps getter-metoden för att komma åt eller ringa setteren för att ställa in en fastighet i Kotlin-som vi gör i Java.
println (book.title) // "En sång av is och eld"
Eftersom det isbn egendom deklareras med var nyckelord (läs-skriv), kan vi också ändra egenskapsvärdet med hjälp av uppdragsoperatören =.
book.isbn = 1234 println (book.isbn) // 1234
Låt oss se ett annat exempel:
klassbok (var titel: String, val isbn: Långt) valbok = Bok ("En sang av is och eld", 9780007477159) book.isbn = 1234 // fel: skrivskyddad egenskap book.title = "Saker faller bort "// omfördelad titel med värdeHär uppdaterade vi isbn parametern är omöjlig (skrivskyddad) istället - genom att använda val nyckelord. Vi instanserade en klassinstans bok och omplacerade titel egendom värdet "saker faller bort". Observera att när vi försökte omplacera isbn fastighetsvärde till 1234, kompilatorn klagade. Detta beror på att egendomen är oföränderlig, har definierats med val nyckelord.
Var medveten om att genom att deklarera en parameter med var modifierare inom den primära konstruktören, har Kotlin-kompilatorn (bakom kulisserna) hjälpt oss att generera både egenskapstillträdena: getter och setter. Om du använder val, det kommer bara att generera getteren.
/ * Kotlin * / klassbok (var titel: String, val isbn: Lång)
Det betyder att Java-uppringare enkelt kan få eller ställa in egenskapsfältet genom att ringa respektive setter eller getter-metoden. Kom ihåg att detta beror på modifieraren som användes för att definiera egenskapen Kotlin: var eller val.
/ * Java * / Bokbok = Ny bok ("En sång av is och eld", 9780385474542) println (book.getTitle ()) // "En sång av is och eld" book.setTitle ("Things Fall Apart") // sätter nytt värde println (book.getTitle ()) // "Saker faller apart" book.getIsbn () // 9780385474542 book.setIsbn (4545454) // kommer inte att kompileraI det här avsnittet visar jag hur du skapar anpassade accessorer (getters och setters) för en fastighet i Kotlin om du vill. Att skapa en anpassad setter kan vara användbar om du vill validera eller verifiera ett värde innan det är inställt på en klassegenskap. Och en anpassad egenskap getter kan vara användbar när du vill ändra eller ändra värdet som ska returneras.
Eftersom vi vill skapa vår egen anpassade getter eller setter för en egendom måste vi definiera den egenskapen i klasskroppen istället för konstruktorns huvud.
klassbok (val isbn: lång) var title = "default value"
Därför flyttade vi den mutable (read-write) titel egendom i klasskroppen och gav det ett standardvärde (annars skulle det inte kompilera).
var title = "default value" set (värde) if (! value.isNotEmpty ()) kasta IllegalArgumentException ("Titel får inte vara tomt") field = valueDu kan se vi definierade vår egen setter metod satt värde) för titel precis under fastighetsdefinitionen som du inte kan ändra på uppsättning() metod signatur eftersom det här är vad kompilatorn förväntar sig som en egen egenskapssättfunktion.
Parametern värde passerade till uppsättning Metoden representerar det verkliga värdet som tilldelades egenskapen av användare. Du kan ändra parameterns namn om du vill, men värde är mycket föredragen. Vi validerade värde genom att kontrollera om värdet är tomt. Om det är tomt, sluta körning och kasta ett undantag. Annars, omfördela värdet till en speciell fält variabel.
Denna speciella fält variabelt fält inuti uppsättning Metod är ett alias för egenskapens bakgrundsfält-ett bakfält är bara ett fält som används av egenskaper när du vill ändra eller använda fältdata. Till skillnad från värde, Du kan inte byta namn på den här speciella fält variabel.
Det är väldigt lätt att skapa en egen getter för en fastighet i Kotlin.
klass bok (val isbn: lång) var title = "default value" // ... set metod get () return field.toUpperCase ()
Inuti skaffa sig metod, vi returnerar helt enkelt en modifierad fält-i vårt fall återvände vi boktiteln i stor bokstav.
val book = Book (9780007477159) book.title = "En sång av is och eld" println (book.title) // "EN SONG OF ICE AND FIRE" println (book.isbn) // 9780007477159
Observera att varje gång vi ställer in ett värde till titel egendom, dess uppsättning metodblock exekveras-detsamma gäller för skaffa sig metod varje gång vi hämtar det.
Om du vill lära dig om medlemsfunktioner för en Kotlin-klass (vilken typ av funktion som definieras i en klass, ett objekt eller ett gränssnitt), besök posten Fler kul med funktioner i den här serien.
Som jag diskuterade tidigare har vi två typer av konstruktörer i Kotlin: primära och sekundära. Vi har friheten att kombinera dem båda i en enda klass - som ni kan se i exemplet nedan:
Klass Car (val namn: String, val plateNo: String) var new: Boolean = true constructor (namn: String, plateNo: String, new: Boolean): this (name, plateNo) this.new = new
Observera att vi inte kan deklarera egenskaper inom en sekundärkonstruktor, som vi gjorde för den primära konstruktören. Om vi vill göra det måste vi förklara det inom klassens kropp och sedan initiera det i sekundärkonstruktorn.
I koden ovan ställer vi in standardvärdet för ny egendom för klassen Bil (kom ihåg, ny är inte ett nyckelord i Kotlin) -Vi kan sedan använda den sekundära konstruktören för att ändra den om vi vill. I Kotlin måste varje sekundärkonstruktör ringa till den primära konstruktören eller ringa en annan sekundärkonstruktor som kallar den primära konstruktören, vi använder detta sökord för att uppnå det.
Notera också att vi kan ha flera sekundära konstruktörer inne i en klass.
klassbil (valnamn: sträng, valplatta nr: sträng) var nytt: booleskt? = null var färg: String = "" konstruktör (namn: String, plateNo: String, new: Boolean): this (name, plateNo) this.new = new konstruktör (namn: String, plateNo: String, new: Boolean , färg: String): detta (namn, plattaNej, nytt) this.colour = color
Om en klass utökar en superklass, kan vi använda super nyckelord (liknande Java) för att ringa superklasskonstruktören (vi diskuterar arv i Kotlin i ett framtida inlägg).
// kallar direkt huvudkonstruktor val car1 = Bil ("Peugeot 504", "XYZ234") // direkt samtal 1: a sekund. constructor val car2 = Bil ("Peugeot 504", "XYZ234", falskt) // direkt samtal senaste sek. constructor val car3 = Bil ("Peugeot 504", "XYZ234", fel, "grå") Som jag sa tidigare, för att vi uttryckligen ska inkludera en siktmodifierare till en konstruktör i en klass måste vi inkludera konstruktör sökord - som standard är konstruktörer offentliga.
klass Car private constructor (val namn: String, val plateNo: String) // ...
Här gjorde vi konstruktören privat - det betyder att användare inte kan direktisera ett objekt med hjälp av konstruktören direkt. Det här kan vara användbart om du vill att användarna istället ringer till en annan metod (en fabriksmetod) för att göra skapandet av objekt indirekt.
I Kotlin kallas den översta typen i typhierarkin Några. Detta motsvarar Java Objekt typ. Detta innebär att alla klasser i Kotlin uttryckligen ärva från Några typ, inklusive Sträng, int, Dubbel, och så vidare. De Några typen innehåller tre metoder: är lika med, att stränga, och hash-kod.
Vi kan också utnyttja Ingenting klass i Kotlin i funktioner som alltid ger ett undantag, med andra ord, för funktioner som inte avslutas normalt. När en funktion returnerar Ingenting, då vet vi att det kommer att kasta ett undantag. Ingen motsvarande typ av detta slag finns i Java.
roligt kastaException (): Ingenting kasta Undantag ("Undantagsmeddelande"Detta kan vara användbart när du testar felhanteringsbeteendet i dina enhetstest.
Siktmodifierare hjälper oss att begränsa tillgängligheten till vårt API till allmänheten. Vi kan erbjuda olika siktmodifierare till våra klasser, gränssnitt, objekt, metoder eller egenskaper. Kotlin ger oss fyra siktmodifierare:
Detta är standardvärdet, och vilken klass, funktion, egenskap, gränssnitt eller objekt som har denna modifierare kan nås var som helst.
En funktion på toppnivå, gränssnitt eller klass som deklareras som privat kan endast nås inom samma fil.
Vilken funktion eller egendom som deklareras privat Inne i en klass, ett objekt eller ett gränssnitt kan bara vara synligt för andra medlemmar av samma klass, objekt eller gränssnitt.
klasskonto privat val belopp: dubbel = 0,0
De skyddad Modifieraren kan endast tillämpas på egenskaper eller funktioner i en klass, ett objekt eller ett gränssnitt. Det kan inte tillämpas på högnivåfunktioner, klasser eller gränssnitt. Egenskaper eller funktioner med denna modifierare är endast tillgängliga inom klassen som definierar den och någon underklass.
I ett projekt som har en modul (Gradle eller Maven modul), en klass, ett objekt, ett gränssnitt eller en funktion som anges med inre Modifierare som deklareras i den modulen är endast tillgänglig från den modulen.
internklasskonto valbelopp: dubbel = 0,0
Casting innebär att ett objekt av en annan typ omvandlas och konverteras till en annan objekttyp. Till exempel använder vi i Java instans av operatör för att bestämma om en viss objekttyp är av en annan typ innan vi sedan slänger den.
/ * Java * / if (form instanceof Circle) Circle circle = (Circle) form; circle.calCircumference (3,5);
Som du kan se, vi kollade om form exemplet är Cirkel, och då måste vi uttryckligen kasta form hänvisning till a Cirkel skriv så att vi kan kalla metoder för cirkel typ.
En annan fantastisk sak om Kotlin är smartens kompilator när det gäller gjutning. Låt oss nu se en version i Kotlin.
/ * Kotlin * / om (form är cirkel) shape.calCircumference (3.5)
Ganska snyggt! Kompilatorn är smart att veta att om block kommer endast att utföras om form objekt är en förekomst av Cirkel-så gjutningsmekanismen görs under huven för oss. Vi kan nu enkelt ringa egenskaper eller funktioner hos Cirkel skriv inuti om blockera.
om (form är Circle && shape.hasRadius ()) println ("Cirkelradien är shape.radius")Här, det sista skicket efter && i om header kallas endast när det första villkoret är Sann. Om form det är inte ett Cirkel, då kommer det sista skicket inte att utvärderas.
Vi kan använda som operatör (eller osäker gjutning operatör) för att uttryckligen kasta en referens av en typ till en annan typ i Kotlin.
val cirkel = form som cirkel cirkel.kalcirkel (4)
Om den explicita gjutningsoperationen är olaglig, notera att a ClassCastException kommer att kastas. För att förhindra att ett undantag kastas vid gjutning kan vi använda säker gjutning operatör (eller nollställd operatör) som?.
val cirkel: Circle? = form som? Cirkel
De som? operatören kommer att försöka kasta till den avsedda typen och återgår null om värdet inte kan kastas istället för att kasta ett undantag. Kom ihåg att en liknande mekanism diskuterades i avsnittet Nullability i Nullability, Loops och Conditions post i denna serie. Läs upp där för en uppdatering.
Objekt i Kotlin liknar mer JavaScript-objekt än Java-objekt. Observera att ett objekt i Kotlin inte är en förekomst av en viss klass!
Objekt liknar mycket klasser. Här är några av egenskaperna hos objekt i Kotlin:
i det blockera.Låt oss nu gräva in hur man skapar ett objekt.
objekt Singleton roligt myFunc (): Enhet // gör något
Vi placerar objekt nyckelord före namnet på objektet vi vill skapa. Faktum är att vi skapar singletoner när vi skapar objekt i Kotlin med hjälp av objekt konstruera, eftersom endast en förekomst av ett objekt existerar. Du lär dig mer om detta när vi diskuterar objektets interoperabilitet med Java.
En singleton är ett mjukvarutesignmönster som garanterar att en klass endast har en instans och en global tillgångspunkt till den ges av den klassen. Varje gång flera klasser eller klienter begär klassen får de samma instans av klassen. Du kan kolla in mitt inlägg om singletonmönstret i Java för att lära mig mer om det.
Du kan komma åt objektet eller singleton var som helst i ditt projekt så länge du importerar paketet.
Singleton.myFunc ()
Om du är en Java-kodare, så skapar vi vanligtvis singletoner:
offentlig klass Singleton privat statisk Singleton INSTANCE = null; // Andra instansvariabler kan vara här privata Singleton () ; offentlig statisk synkroniserad Singleton getInstance () if (INSTANCE == null) INSTANCE = new Singleton (); returnera (INSTANCE); // andra exempel metoder kan följa
Som du kan se använder du Kotlin objekt konstruktion gör det koncist och enklare att skapa singletoner.
Objekt i Kotlin kan utnyttjas också för att skapa konstanter. Vanligen i Java skapar vi konstanter i en klass genom att göra det till ett offentligt statiskt slutfält som följande:
offentliga slutliga klass APIConstanter offentliga statiska slutliga strängbasen Url = "http://www.myapi.com/"; privata APIConstants ()
Denna kod i Java kan omvandlas till Kotlin mer kortfattat så här:
paket com.chike.kotlin.constants objekt APIConstants val baseUrl: String = "http://www.myapi.com/"
Här förklarade vi konstanten APIConstants med en fastighet baseUrl inuti ett paket com.chike.kotlin.constants. Under huven, en Java privat statisk slutlig medlem baseUrl är skapad för oss och initialiserad med strängadressen.
För att använda denna konstant i ett annat paket i Kotlin, importera du enkelt paketet.
importera com.chike.kotlin.constants.APIConstants APIConstants.baseUrl
Kotlin omvandlar ett objekt till en sista Java-klass under huven. Denna klass har ett privat statiskt fält EXEMPEL som innehar en enda instans (en singleton) av klassen. Följande kod visar hur enkelt användare kan ringa ett Kotlin-objekt från Java.
/ * Java * / Singleton.INSTANCE.myFunc ()
Här heter en Java-klass Singleton genererades med en offentlig statisk slutlig medlem EXEMPEL, inklusive en offentlig slutfunktion myFunc ().
För att objektobjektet eller egenskapen i Kotlin ska vara en statisk medlem av den genererade Java-klassen använder vi @JvmStatic anteckning. Så här använder du den:
objekt Singleton @JvmStatic fun myFunc (): Enhet // gör något
Genom att tillämpa @JvmStatic anteckning till myFunc (), kompilatorn har gjort det till en statisk funktion.
Nu kan Java-röstare ringa det som ett normalt statiskt medlemssamtal. Observera att du använder EXEMPEL statiskt fält att ringa medlemmar kommer fortfarande att fungera.
/ * Java * / Singleton.myFunc ()
Nu har vi förstått vilka föremål som finns i Kotlin, låt oss dyka in i en annan typ av föremål som kallas följeslagare.
Eftersom Kotlin inte stöder statiska klasser, metoder eller egenskaper som de vi har i Java, gav Kotlin-teamet oss ett kraftfullare alternativ som heter följeslagare objekt. Ett följeslag är i grunden ett objekt som tillhör en klass - den här klassen är känd som objektets kompanjonsklass. Detta innebär också att de egenskaper jag nämnde för föremål också gäller för följeslagare.
Liknande statiska metoder i Java är inte ett kompanionsobjekt associerat med en klassinstans utan snarare med klassen själv, till exempel en fabriksstatisk metod som har jobbet att skapa en klassinstans.
Klass Person Personlig Konstruktör (Var FirstName: String, Var LastName: String) Companion Object Fun Skapa (Förnamn: String, LastName: String): Person = Person (Förnamn, Efternamn)
Här gjorde vi konstruktören privat-Det innebär att användare utanför klassen inte kan skapa en instans direkt. Inom vårt kompanionsobjekt har vi en funktion skapa(), vilket skapar en Person objekt och returnera det.
följeslagare Objekt-instansering är lat. Med andra ord, det kommer att bli instantiated endast vid behov första gången. Inställningen av a följeslagare objekt händer när en instans av följeslagare klassen skapas eller följeslagare objekt medlemmar är åtkomliga.
Låt oss se hur man åberopar en kompanionsobjektfunktion i Kotlin.
val person = Person.create ("Cersei", "Lannister") println (person.firstName) // utskrifter "Cersei"Som du kan se är det bara som att anropa en statisk metod i Java som vanligt. Med andra ord, vi ringer bara i klassen och ringer sedan till medlemmen. Observera att förutom funktioner kan vi också ha egenskaper inom vårt kompanionsobjekt.
klass person firstName: String, var lastName: String init count ++ kompanionobjekt var count: Int = 0 roligt skapa (firstName: String, LastName: String): Person = Person (firstName, lastName) init println ("Person companion object created")Observera också att följeslagare klassen har obegränsat tillträde till alla egenskaper och funktioner som deklareras i sitt följeslag, medan ett kompanionsobjekt inte kan komma åt klassmedlemmarna. Vi kan ha en i det kodblock inuti a följeslagare objekt - det här kallas omedelbart när kompanionsobjektet skapas.
Person.create ("Arya", "Stark") Person.create ("Daenerys", "Targaryen") println (Person.count)Resultatet av att exekvera koden ovan kommer att vara:
Personkompaniobjekt skapat 2
Kom ihåg, bara en enda förekomst av en klass följeslagare objekt kan någonsin existera.
Vi kan också tillhandahålla vårt kompanionsobjekt med ett namn.
// ... kompanion objekt Fabrik var räkna: Int = 0 roligt skapa (firstName: String, LastName: String): Person = Person (firstName, LastName) // ...
Här gav vi det ett namn som heter Fabrik. Vi kan då kalla det så här i Kotlin:
Person.Factory.create ("Petyr", "Baelish")Denna stil är verbos, så att hålla fast vid den föregående vägen är mycket föredragen. Men det här kan komma till nytta när du ringer en kompanionsobjektfunktion eller egenskap från Java.
Som jag sa tidigare, som föremål kan kompanionsobjekt också innehålla egenskaper eller funktioner, implementera gränssnitt och till och med utöka en klass.
PersonFactory förnamn: String) companion object: PersonFactory : Person returnera person (förnamn, efternamn)
Här har vi ett gränssnitt PersonFactory med bara en singel skapa() fungera. Titta på vår nya modifierade följeslagare objekt, det implementerar nu detta gränssnitt (du lär dig om gränssnitt och arv i Kotlin i ett senare inlägg).
Under huven sammanställs kompanionsobjekt på samma sätt som ett Kotlin-objekt sammanställs. I vårt eget fall genereras två klasser för oss: en final Person klass och en inre statisk slutklass Person $ Companion.
De Person klassen innehåller en slutlig statisk medlem som heter Följeslagare-detta statiska fält är ett föremål för Person $ Companion inre klassen. De Person $ Companion inre klass har också sina egna medlemmar, och en av dem är en offentlig slutlig funktion som heter skapa().
Observera att vi inte gav vårt kompanionsobjekt ett namn, så den genererade statiska inre klassen var Följeslagare. Om vi hade gett det ett namn, skulle det genererade namnet vara det namn vi gav det i Kotlin.
/ * Java * / Person person = Person.Companion.create ("Jon", "Snow"); Här har kompanionsobjektet i Kotlin inget namn, så vi använder namnet Följeslagare som tillhandahålls av kompilatorn för Java-anropare för att ringa det.
De @JvmStatic annotering som tillämpas på en kompanionsobjektmedlem fungerar på samma sätt som hur det fungerar för ett vanligt föremål.
På samma sätt som hur förlängningsfunktioner kan förlänga funktionaliteten hos en klass kan vi också förlänga funktionaliteten för ett kompanionsobjekt. (Om du vill ha en uppdatering av utökningsfunktioner i Kotlin, besök handledning för avancerade funktioner i den här serien).
klass ClassA companion object kul ClassA.Companion.extFunc () // ... gör implementation ClassA.extFunc ()
Här definierade vi en förlängningsfunktion extFunc () på kompanionsobjektet ClassA.Companion. Med andra ord, extfunc () är en förlängning av kompanionsobjektet. Då kan vi ringa tillägget som om det är en medlemsfunktion (det är inte!) Av kompanionsobjektet.
Bakom kulisserna skapar kompilatorn en statisk nyttafunktion extFunc (). Mottagarobjektet som ett argument för denna funktion är KlassA $ Companion.
I denna handledning lärde du dig om grundläggande klasser och objekt i Kotlin. Vi omfattade följande om klasser:
Du lärde dig också om hur objekt och kompisobjekt i Kotlin enkelt kan ersätta dina statiska metoder, konstanter och singletoner du kodar i Java. Men det är inte allt! Det finns fortfarande mer att lära sig om klasser i Kotlin. I nästa inlägg visar jag ännu mer coola funktioner som Kotlin har för objektorienterad programmering. Ses snart!
För att lära mig mer om Kotlins språket rekommenderar jag att du besöker Kotlins dokumentation. Eller kolla in några av våra andra Android App-utvecklingsposter här på Envato Tuts+!
